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 #include <time.h>
 423
 424 #include <dali/dali.h>
 425 #include <dali-toolkit/dali-toolkit.h>
 426
 427 #include <dali/devel-api/actors/actor-devel.h>
 428 #include <dali/devel-api/common/stage-devel.h>
 429 #include <dali/devel-api/events/key-event-devel.h>
 430
 431 #include <dali/public-api/math/matrix.h>
 432 #include <dali/public-api/math/matrix3.h>
 433 #include <dali/public-api/math/viewport.h>
 434 #include <dali/public-api/object/property-key.h>
 435 #include <dali/devel-api/object/csharp-type-info.h>
 436 #include <dali/devel-api/object/csharp-type-registry.h>
 437
 438 #include <dali/public-api/adaptor-framework/timer.h>
 439 #include <dali/public-api/adaptor-framework/style-change.h>
 440 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 441
 442 #include <dali-toolkit/devel-api/accessibility-manager/accessibility-manager.h>
 443
 444 #include <dali-toolkit/devel-api/builder/builder.h>
 445
 446 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 447 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 448
 449 #include <dali-toolkit/devel-api/controls/control-devel.h>
 450 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 451 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 455 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 456 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 457 #include <dali-toolkit/devel-api/controls/alignment/alignment.h>
 458 #include <dali-toolkit/devel-api/controls/scroll-bar/scroll-bar.h>
 459 #include <dali-toolkit/devel-api/controls/table-view/table-view.h>
 460
 461 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 462 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 463 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 464
 465 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 466 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 467 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 468
 469 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 470 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 471 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 472
 473 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 474
 475 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 476 #include <dali/devel-api/adaptor-framework/image-loading.h>
 477
 478 #include <dali/public-api/events/mouse-button.h>
 479
 480 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 481 #include "web-view-signal-converter.h"
 482
 483 #include <dali/integration-api/debug.h>
 484
 485 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 486
 487 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 488
 489 #include <dali-toolkit/devel-api/text/rendering-backend.h>
 490
 491
 492 #include <dali/devel-api/update/frame-callback-interface.h>
 493 #include <dali/devel-api/update/update-proxy.h>
 494
 495
 496 // add here SWIG version check
 497
 498 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 499 // disable Swig-dependent warnings
 500
 501 // 'identifier1' has C-linkage specified,
 502 // but returns UDT 'identifier2' which is incompatible with C
 503 #pragma warning(disable: 4190)
 504
 505 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 506 #pragma warning(disable: 4800)
 507
 508 // debug info too long etc etc
 509 #pragma warning(disable: 4786)
 510 #endif
 511
 512
 513 #include <stdexcept>
 514
 515
 516 #include <string>
 517
 518
 519 #include <vector>
 520 #include <algorithm>
 521 #include <stdexcept>
 522
 523
 524 #include <map>
 525 #include <algorithm>
 526 #include <stdexcept>
 527
 528
 529 #include <utility>
 530
 531
 532 typedef float floatp;
 533
 534 SWIGINTERN floatp *new_floatp(){
 535   return new float();
 536 }
 537 SWIGINTERN void delete_floatp(floatp *self){
 538   if (self) delete self;
 539 }
 540 SWIGINTERN void floatp_assign(floatp *self,float value){
 541   *self = value;
 542 }
 543 SWIGINTERN float floatp_value(floatp *self){
 544   return *self;
 545 }
 546 SWIGINTERN float *floatp_cast(floatp *self){
 547   return self;
 548 }
 549 SWIGINTERN floatp *floatp_frompointer(float *t){
 550   return (floatp *) t;
 551 }
 552
 553 typedef int intp;
 554
 555 SWIGINTERN intp *new_intp(){
 556   return new int();
 557 }
 558 SWIGINTERN void delete_intp(intp *self){
 559   if (self) delete self;
 560 }
 561 SWIGINTERN void intp_assign(intp *self,int value){
 562   *self = value;
 563 }
 564 SWIGINTERN int intp_value(intp *self){
 565   return *self;
 566 }
 567 SWIGINTERN int *intp_cast(intp *self){
 568   return self;
 569 }
 570 SWIGINTERN intp *intp_frompointer(int *t){
 571   return (intp *) t;
 572 }
 573
 574 typedef double doublep;
 575
 576 SWIGINTERN doublep *new_doublep(){
 577   return new double();
 578 }
 579 SWIGINTERN void delete_doublep(doublep *self){
 580   if (self) delete self;
 581 }
 582 SWIGINTERN void doublep_assign(doublep *self,double value){
 583   *self = value;
 584 }
 585 SWIGINTERN double doublep_value(doublep *self){
 586   return *self;
 587 }
 588 SWIGINTERN double *doublep_cast(doublep *self){
 589   return self;
 590 }
 591 SWIGINTERN doublep *doublep_frompointer(double *t){
 592   return (doublep *) t;
 593 }
 594
 595 typedef unsigned int uintp;
 596
 597 SWIGINTERN uintp *new_uintp(){
 598   return new unsigned int();
 599 }
 600 SWIGINTERN void delete_uintp(uintp *self){
 601   if (self) delete self;
 602 }
 603 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 604   *self = value;
 605 }
 606 SWIGINTERN unsigned int uintp_value(uintp *self){
 607   return *self;
 608 }
 609 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 610   return self;
 611 }
 612 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 613   return (uintp *) t;
 614 }
 615
 616 typedef unsigned short ushortp;
 617
 618 SWIGINTERN ushortp *new_ushortp(){
 619   return new unsigned short();
 620 }
 621 SWIGINTERN void delete_ushortp(ushortp *self){
 622   if (self) delete self;
 623 }
 624 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 625   *self = value;
 626 }
 627 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 628   return *self;
 629 }
 630 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 631   return self;
 632 }
 633 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 634   return (ushortp *) t;
 635 }
 636
 637 unsigned int int_to_uint(int x) {
 638    return (unsigned int) x;
 639 }
 640
 641
 642 using namespace Dali;
 643 using namespace Dali::Toolkit;
 644
 645 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 646 {
 647   bool result = false;
 648   try
 649   {
 650     // C++ code. DALi uses Handle <-> Body design pattern.
 651     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 652     // Handles in DALi can be converted into a boolean type
 653     // to check if the handle has a valid body attached to it.
 654     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 655     if( *self )
 656     {
 657       result = true;
 658     }
 659     else
 660     {
 661       result = false;
 662     }
 663   }
 664   catch (std::out_of_range& e)
 665   {
 666     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 667     return 0;
 668   }
 669   catch (std::exception& e)
 670   {
 671     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 672     return 0;
 673   }
 674   catch (DaliException e)
 675   {
 676     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 677     return 0;
 678   }
 679   catch (...)
 680   {
 681     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 682     return 0;
 683   }
 684   return result;
 685 }
 686
 687 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 688 {
 689   bool result = false;
 690   try
 691   {
 692     // C++ code. Check if two handles reference the same implemtion
 693     if( *self == rhs)
 694     {
 695       result = true;
 696     }
 697     else
 698     {
 699       result = false;
 700     }
 701   }
 702   catch (std::out_of_range& e)
 703   {
 704     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 705     return 0;
 706   }
 707   catch (std::exception& e)
 708   {
 709     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 710     return 0;
 711   }
 712   catch (DaliException e)
 713   {
 714     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 715     return 0;
 716   }
 717   catch (...)
 718   {
 719     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 720     return 0;
 721   }
 722   return result;
 723 }
 724
 725
 726 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 727      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 728    }
 729 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){
 730      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 731    }
 732 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 733         std::vector< Dali::TouchPoint >* pv = 0;
 734         if (capacity >= 0) {
 735           pv = new std::vector< Dali::TouchPoint >();
 736           pv->reserve(capacity);
 737        } else {
 738           throw std::out_of_range("capacity");
 739        }
 740        return pv;
 741       }
 742 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 743         if (index>=0 && index<(int)self->size())
 744           return (*self)[index];
 745         else
 746           throw std::out_of_range("index");
 747       }
 748 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 749         if (index>=0 && index<(int)self->size())
 750           return (*self)[index];
 751         else
 752           throw std::out_of_range("index");
 753       }
 754 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 755         if (index>=0 && index<(int)self->size())
 756           (*self)[index] = val;
 757         else
 758           throw std::out_of_range("index");
 759       }
 760 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 761         self->insert(self->end(), values.begin(), values.end());
 762       }
 763 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 764         if (index < 0)
 765           throw std::out_of_range("index");
 766         if (count < 0)
 767           throw std::out_of_range("count");
 768         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 769           throw std::invalid_argument("invalid range");
 770         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 771       }
 772 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 773         if (index>=0 && index<(int)self->size()+1)
 774           self->insert(self->begin()+index, x);
 775         else
 776           throw std::out_of_range("index");
 777       }
 778 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 779         if (index>=0 && index<(int)self->size()+1)
 780           self->insert(self->begin()+index, values.begin(), values.end());
 781         else
 782           throw std::out_of_range("index");
 783       }
 784 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 785         if (index>=0 && index<(int)self->size())
 786           self->erase(self->begin() + index);
 787         else
 788           throw std::out_of_range("index");
 789       }
 790 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 791         if (index < 0)
 792           throw std::out_of_range("index");
 793         if (count < 0)
 794           throw std::out_of_range("count");
 795         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 796           throw std::invalid_argument("invalid range");
 797         self->erase(self->begin()+index, self->begin()+index+count);
 798       }
 799 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 800         if (count < 0)
 801           throw std::out_of_range("count");
 802         return new std::vector< Dali::TouchPoint >(count, value);
 803       }
 804 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 805         std::reverse(self->begin(), self->end());
 806       }
 807 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 808         if (index < 0)
 809           throw std::out_of_range("index");
 810         if (count < 0)
 811           throw std::out_of_range("count");
 812         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 813           throw std::invalid_argument("invalid range");
 814         std::reverse(self->begin()+index, self->begin()+index+count);
 815       }
 816 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 817         if (index < 0)
 818           throw std::out_of_range("index");
 819         if (index+values.size() > self->size())
 820           throw std::out_of_range("index");
 821         std::copy(values.begin(), values.end(), self->begin()+index);
 822       }
 823 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 824          return self->Empty();
 825       }
 826 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 827         return self->GetConnectionCount();
 828       }
 829 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 830           self->Connect( func );
 831       }
 832 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 833           self->Disconnect( func );
 834       }
 835 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 836           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 837 /*@SWIG@*/ self->Emit( arg );
 838       }
 839 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 840          return self->Empty();
 841       }
 842 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 843         return self->GetConnectionCount();
 844       }
 845 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 846           self->Connect( func );
 847       }
 848 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 849           self->Disconnect( func );
 850       }
 851 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 852           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 853 /*@SWIG@*/ self->Emit( arg );
 854       }
 855 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 856          return self->Empty();
 857       }
 858 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){
 859         return self->GetConnectionCount();
 860       }
 861 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 *)){
 862           self->Connect( func );
 863       }
 864 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 *)){
 865           self->Disconnect( func );
 866       }
 867 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){
 868           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 869 /*@SWIG@*/ self->Emit( arg );
 870       }
 871 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 872          return self->Empty();
 873       }
 874 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 875         return self->GetConnectionCount();
 876       }
 877 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 878           self->Connect( func );
 879       }
 880 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 881           self->Disconnect( func );
 882       }
 883 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 884           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 885 /*@SWIG@*/ self->Emit( arg );
 886       }
 887 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){
 888          return self->Empty();
 889       }
 890 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){
 891         return self->GetConnectionCount();
 892       }
 893 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 &)){
 894         self->Connect( func );
 895       }
 896 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 &)){
 897         self->Disconnect( func );
 898       }
 899 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){
 900         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 901 /*@SWIG@*/ self->Emit( arg1, arg2 );
 902       }
 903 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *self){
 904          return self->Empty();
 905       }
 906 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *self){
 907         return self->GetConnectionCount();
 908       }
 909 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Actor,Dali::TouchEvent const &)){
 910         self->Connect( func );
 911       }
 912 SWIGINTERN void Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,bool (*func)(Dali::Actor,Dali::TouchEvent const &)){
 913         self->Disconnect( func );
 914       }
 915 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *self,Dali::Actor arg1,Dali::TouchEvent const &arg2){
 916         return self->Emit( arg1, arg2 );
 917       }
 918 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){
 919          return self->Empty();
 920       }
 921 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){
 922         return self->GetConnectionCount();
 923       }
 924 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 &)){
 925         self->Connect( func );
 926       }
 927 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 &)){
 928         self->Disconnect( func );
 929       }
 930 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){
 931         return self->Emit( arg1, arg2 );
 932       }
 933 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){
 934          return self->Empty();
 935       }
 936 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){
 937         return self->GetConnectionCount();
 938       }
 939 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 &)){
 940         self->Connect( func );
 941       }
 942 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 &)){
 943         self->Disconnect( func );
 944       }
 945 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){
 946         return self->Emit( arg1, arg2 );
 947       }
 948 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 949          return self->Empty();
 950       }
 951 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 952         return self->GetConnectionCount();
 953       }
 954 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 955           self->Connect( func );
 956       }
 957 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 958           self->Disconnect( func );
 959       }
 960 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 961           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 962 /*@SWIG@*/ self->Emit( arg );
 963       }
 964 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 965          return self->Empty();
 966       }
 967 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){
 968         return self->GetConnectionCount();
 969       }
 970 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 &)){
 971           self->Connect( func );
 972       }
 973 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 &)){
 974           self->Disconnect( func );
 975       }
 976 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){
 977           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 978 /*@SWIG@*/ self->Emit( arg );
 979       }
 980 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 981          return self->Empty();
 982       }
 983 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::TouchEvent const &) > const *self){
 984         return self->GetConnectionCount();
 985       }
 986 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(Dali::Signal< void (Dali::TouchEvent const &) > *self,void (*func)(Dali::TouchEvent const &)){
 987           self->Connect( func );
 988       }
 989 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::TouchEvent const &) > *self,void (*func)(Dali::TouchEvent const &)){
 990           self->Disconnect( func );
 991       }
 992 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(Dali::Signal< void (Dali::TouchEvent const &) > *self,Dali::TouchEvent const &arg){
 993           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 994 /*@SWIG@*/ self->Emit( arg );
 995       }
 996 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 997          return self->Empty();
 998       }
 999 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){
1000         return self->GetConnectionCount();
1001       }
1002 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 &)){
1003           self->Connect( func );
1004       }
1005 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 &)){
1006           self->Disconnect( func );
1007       }
1008 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){
1009           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1010 /*@SWIG@*/ self->Emit( arg );
1011       }
1012 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){
1013          return self->Empty();
1014       }
1015 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){
1016         return self->GetConnectionCount();
1017       }
1018 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 &)){
1019         self->Connect( func );
1020       }
1021 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 &)){
1022         self->Disconnect( func );
1023       }
1024 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){
1025         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1026 /*@SWIG@*/ self->Emit( arg1, arg2 );
1027       }
1028 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){
1029          return self->Empty();
1030       }
1031 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){
1032         return self->GetConnectionCount();
1033       }
1034 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 &)){
1035         self->Connect( func );
1036       }
1037 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 &)){
1038         self->Disconnect( func );
1039       }
1040 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){
1041         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1042 /*@SWIG@*/ self->Emit( arg1, arg2 );
1043       }
1044 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){
1045          return self->Empty();
1046       }
1047 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){
1048         return self->GetConnectionCount();
1049       }
1050 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 &)){
1051         self->Connect( func );
1052       }
1053 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 &)){
1054         self->Disconnect( func );
1055       }
1056 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){
1057         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1058 /*@SWIG@*/ self->Emit( arg1, arg2 );
1059       }
1060 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){
1061          return self->Empty();
1062       }
1063 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){
1064         return self->GetConnectionCount();
1065       }
1066 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)){
1067           return self->Connect( func );
1068       }
1069 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)){
1070           self->Disconnect( func );
1071       }
1072 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){
1073           self->Emit( arg1, arg3 );
1074       }
1075 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){
1076          return self->Empty();
1077       }
1078 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){
1079         return self->GetConnectionCount();
1080       }
1081 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)){
1082           return self->Connect( func );
1083       }
1084 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)){
1085           self->Disconnect( func );
1086       }
1087 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){
1088           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1089 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1090       }
1091
1092 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1093          return self->Empty();
1094       }
1095 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1096         return self->GetConnectionCount();
1097       }
1098 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1099           self->Connect( func );
1100       }
1101 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1102           self->Disconnect( func );
1103       }
1104 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1105           return self->Emit();
1106       }
1107
1108 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1109         std::vector< unsigned int >* pv = 0;
1110         if (capacity >= 0) {
1111           pv = new std::vector< unsigned int >();
1112           pv->reserve(capacity);
1113        } else {
1114           throw std::out_of_range("capacity");
1115        }
1116        return pv;
1117       }
1118 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1119         if (index>=0 && index<(int)self->size())
1120           return (*self)[index];
1121         else
1122           throw std::out_of_range("index");
1123       }
1124 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1125         if (index>=0 && index<(int)self->size())
1126           return (*self)[index];
1127         else
1128           throw std::out_of_range("index");
1129       }
1130 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1131         if (index>=0 && index<(int)self->size())
1132           (*self)[index] = val;
1133         else
1134           throw std::out_of_range("index");
1135       }
1136 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1137         self->insert(self->end(), values.begin(), values.end());
1138       }
1139 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1140         if (index < 0)
1141           throw std::out_of_range("index");
1142         if (count < 0)
1143           throw std::out_of_range("count");
1144         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1145           throw std::invalid_argument("invalid range");
1146         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1147       }
1148 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1149         if (index>=0 && index<(int)self->size()+1)
1150           self->insert(self->begin()+index, x);
1151         else
1152           throw std::out_of_range("index");
1153       }
1154 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1155         if (index>=0 && index<(int)self->size()+1)
1156           self->insert(self->begin()+index, values.begin(), values.end());
1157         else
1158           throw std::out_of_range("index");
1159       }
1160 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1161         if (index>=0 && index<(int)self->size())
1162           self->erase(self->begin() + index);
1163         else
1164           throw std::out_of_range("index");
1165       }
1166 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1167         if (index < 0)
1168           throw std::out_of_range("index");
1169         if (count < 0)
1170           throw std::out_of_range("count");
1171         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1172           throw std::invalid_argument("invalid range");
1173         self->erase(self->begin()+index, self->begin()+index+count);
1174       }
1175 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1176         if (count < 0)
1177           throw std::out_of_range("count");
1178         return new std::vector< unsigned int >(count, value);
1179       }
1180 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1181         std::reverse(self->begin(), self->end());
1182       }
1183 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1184         if (index < 0)
1185           throw std::out_of_range("index");
1186         if (count < 0)
1187           throw std::out_of_range("count");
1188         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1189           throw std::invalid_argument("invalid range");
1190         std::reverse(self->begin()+index, self->begin()+index+count);
1191       }
1192 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1193         if (index < 0)
1194           throw std::out_of_range("index");
1195         if (index+values.size() > self->size())
1196           throw std::out_of_range("index");
1197         std::copy(values.begin(), values.end(), self->begin()+index);
1198       }
1199 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1200         return std::find(self->begin(), self->end(), value) != self->end();
1201       }
1202 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1203         int index = -1;
1204         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1205         if (it != self->end())
1206           index = (int)(it - self->begin());
1207         return index;
1208       }
1209 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1210         int index = -1;
1211         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1212         if (rit != self->rend())
1213           index = (int)(self->rend() - 1 - rit);
1214         return index;
1215       }
1216 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1217         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1218         if (it != self->end()) {
1219           self->erase(it);
1220           return true;
1221         }
1222         return false;
1223       }
1224 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){
1225         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1226         if (capacity >= 0) {
1227           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1228           pv->reserve(capacity);
1229        } else {
1230           throw std::out_of_range("capacity");
1231        }
1232        return pv;
1233       }
1234 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){
1235         if (index>=0 && index<(int)self->size())
1236           return (*self)[index];
1237         else
1238           throw std::out_of_range("index");
1239       }
1240 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){
1241         if (index>=0 && index<(int)self->size())
1242           return (*self)[index];
1243         else
1244           throw std::out_of_range("index");
1245       }
1246 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){
1247         if (index>=0 && index<(int)self->size())
1248           (*self)[index] = val;
1249         else
1250           throw std::out_of_range("index");
1251       }
1252 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){
1253         self->insert(self->end(), values.begin(), values.end());
1254       }
1255 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){
1256         if (index < 0)
1257           throw std::out_of_range("index");
1258         if (count < 0)
1259           throw std::out_of_range("count");
1260         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1261           throw std::invalid_argument("invalid range");
1262         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1263       }
1264 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){
1265         if (index>=0 && index<(int)self->size()+1)
1266           self->insert(self->begin()+index, x);
1267         else
1268           throw std::out_of_range("index");
1269       }
1270 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){
1271         if (index>=0 && index<(int)self->size()+1)
1272           self->insert(self->begin()+index, values.begin(), values.end());
1273         else
1274           throw std::out_of_range("index");
1275       }
1276 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){
1277         if (index>=0 && index<(int)self->size())
1278           self->erase(self->begin() + index);
1279         else
1280           throw std::out_of_range("index");
1281       }
1282 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){
1283         if (index < 0)
1284           throw std::out_of_range("index");
1285         if (count < 0)
1286           throw std::out_of_range("count");
1287         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1288           throw std::invalid_argument("invalid range");
1289         self->erase(self->begin()+index, self->begin()+index+count);
1290       }
1291 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){
1292         if (count < 0)
1293           throw std::out_of_range("count");
1294         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1295       }
1296 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){
1297         std::reverse(self->begin(), self->end());
1298       }
1299 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){
1300         if (index < 0)
1301           throw std::out_of_range("index");
1302         if (count < 0)
1303           throw std::out_of_range("count");
1304         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1305           throw std::invalid_argument("invalid range");
1306         std::reverse(self->begin()+index, self->begin()+index+count);
1307       }
1308 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){
1309         if (index < 0)
1310           throw std::out_of_range("index");
1311         if (index+values.size() > self->size())
1312           throw std::out_of_range("index");
1313         std::copy(values.begin(), values.end(), self->begin()+index);
1314       }
1315 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1316         std::vector< Dali::Actor >* pv = 0;
1317         if (capacity >= 0) {
1318           pv = new std::vector< Dali::Actor >();
1319           pv->reserve(capacity);
1320        } else {
1321           throw std::out_of_range("capacity");
1322        }
1323        return pv;
1324       }
1325 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1326         if (index>=0 && index<(int)self->size())
1327           return (*self)[index];
1328         else
1329           throw std::out_of_range("index");
1330       }
1331 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1332         if (index>=0 && index<(int)self->size())
1333           return (*self)[index];
1334         else
1335           throw std::out_of_range("index");
1336       }
1337 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1338         if (index>=0 && index<(int)self->size())
1339           (*self)[index] = val;
1340         else
1341           throw std::out_of_range("index");
1342       }
1343 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1344         self->insert(self->end(), values.begin(), values.end());
1345       }
1346 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1347         if (index < 0)
1348           throw std::out_of_range("index");
1349         if (count < 0)
1350           throw std::out_of_range("count");
1351         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1352           throw std::invalid_argument("invalid range");
1353         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1354       }
1355 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1356         if (index>=0 && index<(int)self->size()+1)
1357           self->insert(self->begin()+index, x);
1358         else
1359           throw std::out_of_range("index");
1360       }
1361 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1362         if (index>=0 && index<(int)self->size()+1)
1363           self->insert(self->begin()+index, values.begin(), values.end());
1364         else
1365           throw std::out_of_range("index");
1366       }
1367 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1368         if (index>=0 && index<(int)self->size())
1369           self->erase(self->begin() + index);
1370         else
1371           throw std::out_of_range("index");
1372       }
1373 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1374         if (index < 0)
1375           throw std::out_of_range("index");
1376         if (count < 0)
1377           throw std::out_of_range("count");
1378         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1379           throw std::invalid_argument("invalid range");
1380         self->erase(self->begin()+index, self->begin()+index+count);
1381       }
1382 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1383         if (count < 0)
1384           throw std::out_of_range("count");
1385         return new std::vector< Dali::Actor >(count, value);
1386       }
1387 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1388         std::reverse(self->begin(), self->end());
1389       }
1390 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1391         if (index < 0)
1392           throw std::out_of_range("index");
1393         if (count < 0)
1394           throw std::out_of_range("count");
1395         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1396           throw std::invalid_argument("invalid range");
1397         std::reverse(self->begin()+index, self->begin()+index+count);
1398       }
1399 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1400         if (index < 0)
1401           throw std::out_of_range("index");
1402         if (index+values.size() > self->size())
1403           throw std::out_of_range("index");
1404         std::copy(values.begin(), values.end(), self->begin()+index);
1405       }
1406 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1407          return self->Empty();
1408       }
1409 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1410         return self->GetConnectionCount();
1411       }
1412 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 &)){
1413           self->Connect( func );
1414       }
1415 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 &)){
1416           self->Disconnect( func );
1417       }
1418 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){
1419           return self->Emit( arg );
1420       }
1421 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){
1422          return self->Empty();
1423       }
1424 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){
1425         return self->GetConnectionCount();
1426       }
1427 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)){
1428         self->Connect( func );
1429       }
1430 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)){
1431         self->Disconnect( func );
1432       }
1433 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){
1434         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1435 /*@SWIG@*/ self->Emit( arg1, arg2 );
1436       }
1437 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1438          return self->Empty();
1439       }
1440 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){
1441         return self->GetConnectionCount();
1442       }
1443 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)){
1444         self->Connect( func );
1445       }
1446 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)){
1447         self->Disconnect( func );
1448       }
1449 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){
1450         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1451 /*@SWIG@*/ self->Emit( arg1, arg2 );
1452       }
1453 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1454          return self->Empty();
1455       }
1456 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1457         return self->GetConnectionCount();
1458       }
1459 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)){
1460         self->Connect( func );
1461       }
1462 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)){
1463         self->Disconnect( func );
1464       }
1465 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){
1466         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1467 /*@SWIG@*/ self->Emit( arg1, arg2 );
1468       }
1469 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){
1470          return self->Empty();
1471       }
1472 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){
1473         return self->GetConnectionCount();
1474       }
1475 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)){
1476         self->Connect( func );
1477       }
1478 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)){
1479         self->Disconnect( func );
1480       }
1481 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){
1482         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1483 /*@SWIG@*/ self->Emit( arg1, arg2 );
1484       }
1485 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1486          return self->Empty();
1487       }
1488 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1489         return self->GetConnectionCount();
1490       }
1491 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)){
1492           self->Connect( func );
1493       }
1494 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)){
1495           self->Disconnect( func );
1496       }
1497 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1498           return self->Emit( arg );
1499       }
1500 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1501          return self->Empty();
1502       }
1503 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1504         return self->GetConnectionCount();
1505       }
1506 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)){
1507           self->Connect( func );
1508       }
1509 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)){
1510           self->Disconnect( func );
1511       }
1512 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1513           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1514 /*@SWIG@*/ self->Emit( arg );
1515       }
1516 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){
1517          return self->Empty();
1518       }
1519 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){
1520         return self->GetConnectionCount();
1521       }
1522 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)){
1523           return self->Connect( func );
1524       }
1525 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)){
1526           self->Disconnect( func );
1527       }
1528 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){
1529           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1530 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1531       }
1532 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1533          return self->Empty();
1534       }
1535 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1536         return self->GetConnectionCount();
1537       }
1538 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)){
1539           self->Connect( func );
1540       }
1541 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)){
1542           self->Disconnect( func );
1543       }
1544 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1545           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1546 /*@SWIG@*/ self->Emit( arg );
1547       }
1548 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){
1549          return self->Empty();
1550       }
1551 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){
1552         return self->GetConnectionCount();
1553       }
1554 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)){
1555           return self->Connect( func );
1556       }
1557 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)){
1558           self->Disconnect( func );
1559       }
1560 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){
1561           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1562 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1563       }
1564 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){
1565          return self->Empty();
1566       }
1567 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){
1568         return self->GetConnectionCount();
1569       }
1570 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 &)){
1571           self->Connect( func );
1572       }
1573 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 &)){
1574           self->Disconnect( func );
1575       }
1576 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){
1577           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1578 /*@SWIG@*/ self->Emit( arg );
1579       }
1580 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1581          return self->Empty();
1582       }
1583 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){
1584         return self->GetConnectionCount();
1585       }
1586 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 &)){
1587           self->Connect( func );
1588       }
1589 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 &)){
1590           self->Disconnect( func );
1591       }
1592 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){
1593           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1594 /*@SWIG@*/ self->Emit( arg );
1595       }
1596
1597
1598 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){
1599          return self->Empty();
1600       }
1601 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){
1602         return self->GetConnectionCount();
1603       }
1604 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 &)){
1605         self->Connect( func );
1606       }
1607 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 &)){
1608         self->Disconnect( func );
1609       }
1610 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){
1611         return self->Emit( arg1, arg2 );
1612       }
1613 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1614          return self->Empty();
1615       }
1616 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1617         return self->GetConnectionCount();
1618       }
1619 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)){
1620           self->Connect( func );
1621       }
1622 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)){
1623           self->Disconnect( func );
1624       }
1625 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1626           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1627 /*@SWIG@*/ self->Emit( arg );
1628       }
1629 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1630          return self->Empty();
1631       }
1632 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1633         return self->GetConnectionCount();
1634       }
1635 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 &)){
1636           self->Connect( func );
1637       }
1638 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 &)){
1639           self->Disconnect( func );
1640       }
1641 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){
1642           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1643 /*@SWIG@*/ self->Emit( arg );
1644       }
1645 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1646          return self->Empty();
1647       }
1648 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){
1649         return self->GetConnectionCount();
1650       }
1651 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)){
1652         self->Connect( func );
1653       }
1654 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)){
1655         self->Disconnect( func );
1656       }
1657 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){
1658         return self->Emit( arg1, arg2 );
1659       }
1660 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1661          return self->Empty();
1662       }
1663 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){
1664         return self->GetConnectionCount();
1665       }
1666 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)){
1667         self->Connect( func );
1668       }
1669 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)){
1670         self->Disconnect( func );
1671       }
1672 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){
1673         return self->Emit( arg1, arg2 );
1674       }
1675
1676 /* ---------------------------------------------------
1677  * C++ director class methods
1678  * --------------------------------------------------- */
1679
1680 #include "dali_wrap.h"
1681
1682 /*
1683  *  Widget director
1684  */
1685 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1686   swig_init_callbacks();
1687 }
1688
1689 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1690 }
1691
1692 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1693   char * jcontentInfo = 0 ;
1694   void * jwindow  ;
1695
1696   if (!swig_callbackOnCreate) {
1697     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1698     return;
1699   } else {
1700     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1701     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1702     swig_callbackOnCreate(jcontentInfo, jwindow);
1703   }
1704 }
1705
1706 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1707   char * jcontentInfo = 0 ;
1708   int jtype  ;
1709
1710   if (!swig_callbackOnTerminate) {
1711     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1712     return;
1713   } else {
1714     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1715     jtype = (int)type;
1716     swig_callbackOnTerminate(jcontentInfo, jtype);
1717   }
1718 }
1719
1720 void SwigDirector_WidgetImpl::OnPause() {
1721   if (!swig_callbackOnPause) {
1722     Dali::Internal::Adaptor::Widget::OnPause();
1723     return;
1724   } else {
1725     swig_callbackOnPause();
1726   }
1727 }
1728
1729 void SwigDirector_WidgetImpl::OnResume() {
1730   if (!swig_callbackOnResume) {
1731     Dali::Internal::Adaptor::Widget::OnResume();
1732     return;
1733   } else {
1734     swig_callbackOnResume();
1735   }
1736 }
1737
1738 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1739   void * jwindow  ;
1740
1741   if (!swig_callbackOnResize) {
1742     Dali::Internal::Adaptor::Widget::OnResize(window);
1743     return;
1744   } else {
1745     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1746     swig_callbackOnResize(jwindow);
1747   }
1748 }
1749
1750 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1751   char * jcontentInfo = 0 ;
1752   int jforce  ;
1753
1754   if (!swig_callbackOnUpdate) {
1755     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1756     return;
1757   } else {
1758     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1759     jforce = force;
1760     swig_callbackOnUpdate(jcontentInfo, jforce);
1761   }
1762 }
1763
1764 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1765   void * jslotObserver = 0 ;
1766   void * jcallback = 0 ;
1767
1768   if (!swig_callbackSignalConnected) {
1769     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1770     return;
1771   } else {
1772     jslotObserver = (void *) slotObserver;
1773     jcallback = (void *) callback;
1774     swig_callbackSignalConnected(jslotObserver, jcallback);
1775   }
1776 }
1777
1778 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1779   void * jslotObserver = 0 ;
1780   void * jcallback = 0 ;
1781
1782   if (!swig_callbackSignalDisconnected) {
1783     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1784     return;
1785   } else {
1786     jslotObserver = (void *) slotObserver;
1787     jcallback = (void *) callback;
1788     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1789   }
1790 }
1791
1792 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) {
1793
1794   swig_callbackOnCreate = callbackOnCreate;
1795   swig_callbackOnTerminate = callbackOnTerminate;
1796   swig_callbackOnPause = callbackOnPause;
1797   swig_callbackOnResume = callbackOnResume;
1798   swig_callbackOnResize = callbackOnResize;
1799   swig_callbackOnUpdate = callbackOnUpdate;
1800   swig_callbackSignalConnected = callbackSignalConnected;
1801   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1802 }
1803
1804 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1805   swig_callbackOnCreate = 0;
1806   swig_callbackOnTerminate = 0;
1807   swig_callbackOnPause = 0;
1808   swig_callbackOnResume = 0;
1809   swig_callbackOnResize = 0;
1810   swig_callbackOnUpdate = 0;
1811   swig_callbackSignalConnected = 0;
1812   swig_callbackSignalDisconnected = 0;
1813 }
1814
1815
1816 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1817   swig_init_callbacks();
1818 }
1819
1820 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1821
1822 }
1823
1824
1825 void SwigDirector_ViewImpl::OnSceneConnection(int depth) {
1826   int jdepth  ;
1827
1828   if (!swig_callbackOnSceneConnection) {
1829     Dali::Toolkit::Internal::Control::OnSceneConnection(depth);
1830     return;
1831   } else {
1832     jdepth = depth;
1833     swig_callbackOnSceneConnection(jdepth);
1834   }
1835 }
1836
1837 void SwigDirector_ViewImpl::OnSceneDisconnection() {
1838   if (!swig_callbackOnSceneDisconnection) {
1839     Dali::Toolkit::Internal::Control::OnSceneDisconnection();
1840     return;
1841   } else {
1842     swig_callbackOnSceneDisconnection();
1843   }
1844 }
1845
1846 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1847   void * jchild = 0 ;
1848
1849   if (!swig_callbackOnChildAdd) {
1850     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1851     return;
1852   } else {
1853     jchild = (Dali::Actor *) &child;
1854     swig_callbackOnChildAdd(jchild);
1855   }
1856 }
1857
1858 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1859   void * jchild = 0 ;
1860
1861   if (!swig_callbackOnChildRemove) {
1862     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1863     return;
1864   } else {
1865     jchild = (Dali::Actor *) &child;
1866     swig_callbackOnChildRemove(jchild);
1867   }
1868 }
1869
1870 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1871   int jindex  ;
1872   void * jpropertyValue  ;
1873
1874   if (!swig_callbackOnPropertySet) {
1875     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1876     return;
1877   } else {
1878     jindex = index;
1879     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1880     swig_callbackOnPropertySet(jindex, jpropertyValue);
1881   }
1882 }
1883
1884 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1885   void * jtargetSize = 0 ;
1886
1887   if (!swig_callbackOnSizeSet) {
1888     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1889     return;
1890   } else {
1891     jtargetSize = (Dali::Vector3 *) &targetSize;
1892     swig_callbackOnSizeSet(jtargetSize);
1893   }
1894 }
1895
1896 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1897   void * janimation = 0 ;
1898   void * jtargetSize = 0 ;
1899
1900   if (!swig_callbackOnSizeAnimation) {
1901     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1902     return;
1903   } else {
1904     janimation = (Dali::Animation *) &animation;
1905     jtargetSize = (Dali::Vector3 *) &targetSize;
1906     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1907   }
1908 }
1909
1910 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1911   bool c_result = SwigValueInit< bool >() ;
1912   unsigned int jresult = 0 ;
1913   void * jarg0 = 0 ;
1914
1915   if (!swig_callbackOnHoverEvent) {
1916     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1917   } else {
1918     jarg0 = (Dali::HoverEvent *) &event;
1919     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1920     c_result = jresult ? true : false;
1921   }
1922   return c_result;
1923 }
1924
1925 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1926   bool c_result = SwigValueInit< bool >() ;
1927   unsigned int jresult = 0 ;
1928   void * jarg0 = 0 ;
1929
1930   if (!swig_callbackOnKeyEvent) {
1931     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1932   } else {
1933     jarg0 = (Dali::KeyEvent *) &event;
1934     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1935     c_result = jresult ? true : false;
1936   }
1937   return c_result;
1938 }
1939
1940 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1941   bool c_result = SwigValueInit< bool >() ;
1942   unsigned int jresult = 0 ;
1943   void * jarg0 = 0 ;
1944
1945   if (!swig_callbackOnWheelEvent) {
1946     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1947   } else {
1948     jarg0 = (Dali::WheelEvent *) &event;
1949     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1950     c_result = jresult ? true : false;
1951   }
1952   return c_result;
1953 }
1954
1955 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1956   void * jsize = 0 ;
1957   void * jcontainer = 0 ;
1958
1959   if (!swig_callbackOnRelayout) {
1960     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1961     return;
1962   } else {
1963     jsize = (Dali::Vector2 *) &size;
1964     jcontainer = (Dali::RelayoutContainer *) &container;
1965     swig_callbackOnRelayout(jsize, jcontainer);
1966   }
1967 }
1968
1969 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1970   int jpolicy  ;
1971   int jdimension  ;
1972
1973   if (!swig_callbackOnSetResizePolicy) {
1974     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1975     return;
1976   } else {
1977     jpolicy = (int)policy;
1978     jdimension = (int)dimension;
1979     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1980   }
1981 }
1982
1983 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1984   Dali::Vector3 c_result ;
1985   void * jresult = 0 ;
1986
1987   if (!swig_callbackGetNaturalSize) {
1988     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1989   } else {
1990     jresult = (void *) swig_callbackGetNaturalSize();
1991     if (!jresult) {
1992       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
1993       return c_result;
1994     }
1995     c_result = *(Dali::Vector3 *)jresult;
1996   }
1997   return c_result;
1998 }
1999
2000 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2001   float c_result = SwigValueInit< float >() ;
2002   float jresult = 0 ;
2003   void * jchild = 0 ;
2004   int jdimension  ;
2005
2006   if (!swig_callbackCalculateChildSize) {
2007     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2008   } else {
2009     jchild = (Dali::Actor *) &child;
2010     jdimension = (int)dimension;
2011     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2012     c_result = (float)jresult;
2013   }
2014   return c_result;
2015 }
2016
2017 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2018   float c_result = SwigValueInit< float >() ;
2019   float jresult = 0 ;
2020   float jwidth  ;
2021
2022   if (!swig_callbackGetHeightForWidth) {
2023     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2024   } else {
2025     jwidth = width;
2026     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2027     c_result = (float)jresult;
2028   }
2029   return c_result;
2030 }
2031
2032 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2033   float c_result = SwigValueInit< float >() ;
2034   float jresult = 0 ;
2035   float jheight  ;
2036
2037   if (!swig_callbackGetWidthForHeight) {
2038     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2039   } else {
2040     jheight = height;
2041     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2042     c_result = (float)jresult;
2043   }
2044   return c_result;
2045 }
2046
2047 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2048   bool c_result = SwigValueInit< bool >() ;
2049   unsigned int jresult = 0 ;
2050   int jdimension  ;
2051
2052   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2053     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2054   } else {
2055     jdimension = (int)dimension;
2056     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2057     c_result = jresult ? true : false;
2058   }
2059   return c_result;
2060 }
2061
2062 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2063   int jdimension  ;
2064
2065   if (!swig_callbackOnCalculateRelayoutSize) {
2066     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2067     return;
2068   } else {
2069     jdimension = (int)dimension;
2070     swig_callbackOnCalculateRelayoutSize(jdimension);
2071   }
2072 }
2073
2074 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2075   float jsize  ;
2076   int jdimension  ;
2077
2078   if (!swig_callbackOnLayoutNegotiated) {
2079     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2080     return;
2081   } else {
2082     jsize = size;
2083     jdimension = (int)dimension;
2084     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2085   }
2086 }
2087
2088 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2089   return Dali::CustomActorImpl::GetExtension();
2090 }
2091
2092 void SwigDirector_ViewImpl::OnInitialize() {
2093   if (!swig_callbackOnInitialize) {
2094     Dali::Toolkit::Internal::Control::OnInitialize();
2095     return;
2096   } else {
2097     swig_callbackOnInitialize();
2098   }
2099 }
2100
2101 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2102   void * jstyleManager  ;
2103   int jchange  ;
2104
2105   if (!swig_callbackOnStyleChange) {
2106     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2107     return;
2108   } else {
2109     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2110     jchange = (int)change;
2111     swig_callbackOnStyleChange(jstyleManager, jchange);
2112   }
2113 }
2114
2115 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2116   bool c_result = SwigValueInit< bool >() ;
2117   unsigned int jresult = 0 ;
2118
2119   if (!swig_callbackOnAccessibilityActivated) {
2120     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2121   } else {
2122     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2123     c_result = jresult ? true : false;
2124   }
2125   return c_result;
2126 }
2127
2128 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2129   bool c_result = SwigValueInit< bool >() ;
2130   unsigned int jresult = 0 ;
2131   void * jgesture  ;
2132
2133   if (!swig_callbackOnAccessibilityPan) {
2134     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2135   } else {
2136     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2137     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2138     c_result = jresult ? true : false;
2139   }
2140   return c_result;
2141 }
2142
2143 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2144   bool c_result = SwigValueInit< bool >() ;
2145   unsigned int jresult = 0 ;
2146   unsigned int jisIncrease  ;
2147
2148   if (!swig_callbackOnAccessibilityValueChange) {
2149     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2150   } else {
2151     jisIncrease = isIncrease;
2152     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2153     c_result = jresult ? true : false;
2154   }
2155   return c_result;
2156 }
2157
2158 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2159   bool c_result = SwigValueInit< bool >() ;
2160   unsigned int jresult = 0 ;
2161
2162   if (!swig_callbackOnAccessibilityZoom) {
2163     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2164   } else {
2165     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2166     c_result = jresult ? true : false;
2167   }
2168   return c_result;
2169 }
2170
2171 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2172   if (!swig_callbackOnKeyInputFocusGained) {
2173     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2174     return;
2175   } else {
2176     swig_callbackOnKeyInputFocusGained();
2177   }
2178 }
2179
2180 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2181   if (!swig_callbackOnKeyInputFocusLost) {
2182     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2183     return;
2184   } else {
2185     swig_callbackOnKeyInputFocusLost();
2186   }
2187 }
2188
2189 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2190   Dali::Actor c_result ;
2191   void * jresult = 0 ;
2192   void * jcurrentFocusedActor  ;
2193   int jdirection  ;
2194   unsigned int jloopEnabled  ;
2195
2196   if (!swig_callbackGetNextKeyboardFocusableActor) {
2197     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2198   } else {
2199     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2200     jdirection = (int)direction;
2201     jloopEnabled = loopEnabled;
2202     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2203     if (!jresult) {
2204       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2205       return c_result;
2206     }
2207     c_result = *(Dali::Actor *)jresult;
2208   }
2209   return c_result;
2210 }
2211
2212 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2213   void * jcommitedFocusableActor  ;
2214
2215   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2216     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2217     return;
2218   } else {
2219     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2220     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2221   }
2222 }
2223
2224 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2225   bool c_result = SwigValueInit< bool >() ;
2226   unsigned int jresult = 0 ;
2227
2228   if (!swig_callbackOnKeyboardEnter) {
2229     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2230   } else {
2231     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2232     c_result = jresult ? true : false;
2233   }
2234   return c_result;
2235 }
2236
2237 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2238   void * jpinch = 0 ;
2239
2240   if (!swig_callbackOnPinch) {
2241     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2242     return;
2243   } else {
2244     jpinch = (Dali::PinchGesture *) &pinch;
2245     swig_callbackOnPinch(jpinch);
2246   }
2247 }
2248
2249 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2250   void * jpan = 0 ;
2251
2252   if (!swig_callbackOnPan) {
2253     Dali::Toolkit::Internal::Control::OnPan(pan);
2254     return;
2255   } else {
2256     jpan = (Dali::PanGesture *) &pan;
2257     swig_callbackOnPan(jpan);
2258   }
2259 }
2260
2261 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2262   void * jtap = 0 ;
2263
2264   if (!swig_callbackOnTap) {
2265     Dali::Toolkit::Internal::Control::OnTap(tap);
2266     return;
2267   } else {
2268     jtap = (Dali::TapGesture *) &tap;
2269     swig_callbackOnTap(jtap);
2270   }
2271 }
2272
2273 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2274   void * jlongPress = 0 ;
2275
2276   if (!swig_callbackOnLongPress) {
2277     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2278     return;
2279   } else {
2280     jlongPress = (Dali::LongPressGesture *) &longPress;
2281     swig_callbackOnLongPress(jlongPress);
2282   }
2283 }
2284
2285 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2286   void * jslotObserver = 0 ;
2287   void * jcallback = 0 ;
2288
2289   if (!swig_callbackSignalConnected) {
2290     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2291     return;
2292   } else {
2293     jslotObserver = (void *) slotObserver;
2294     jcallback = (void *) callback;
2295     swig_callbackSignalConnected(jslotObserver, jcallback);
2296   }
2297 }
2298
2299 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2300   void * jslotObserver = 0 ;
2301   void * jcallback = 0 ;
2302
2303   if (!swig_callbackSignalDisconnected) {
2304     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2305     return;
2306   } else {
2307     jslotObserver = (void *) slotObserver;
2308     jcallback = (void *) callback;
2309     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2310   }
2311 }
2312
2313 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2314   return Dali::Toolkit::Internal::Control::GetControlExtension();
2315 }
2316
2317 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_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_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) {
2318   swig_callbackOnSceneConnection = callbackOnSceneConnection;
2319   swig_callbackOnSceneDisconnection = callbackOnSceneDisconnection;
2320   swig_callbackOnChildAdd = callbackOnChildAdd;
2321   swig_callbackOnChildRemove = callbackOnChildRemove;
2322   swig_callbackOnPropertySet = callbackOnPropertySet;
2323   swig_callbackOnSizeSet = callbackOnSizeSet;
2324   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2325   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2326   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2327   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2328   swig_callbackOnRelayout = callbackOnRelayout;
2329   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2330   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2331   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2332   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2333   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2334   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2335   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2336   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2337   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2338   swig_callbackOnInitialize = callbackOnInitialize;
2339   swig_callbackOnStyleChange = callbackOnStyleChange;
2340   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2341   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2342   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2343   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2344   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2345   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2346   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2347   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2348   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2349   swig_callbackOnPinch = callbackOnPinch;
2350   swig_callbackOnPan = callbackOnPan;
2351   swig_callbackOnTap = callbackOnTap;
2352   swig_callbackOnLongPress = callbackOnLongPress;
2353   swig_callbackSignalConnected = callbackSignalConnected;
2354   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2355 }
2356
2357 void SwigDirector_ViewImpl::swig_init_callbacks() {
2358   swig_callbackOnSceneConnection = 0;
2359   swig_callbackOnSceneDisconnection = 0;
2360   swig_callbackOnChildAdd = 0;
2361   swig_callbackOnChildRemove = 0;
2362   swig_callbackOnPropertySet = 0;
2363   swig_callbackOnSizeSet = 0;
2364   swig_callbackOnSizeAnimation = 0;
2365   swig_callbackOnHoverEvent = 0;
2366   swig_callbackOnKeyEvent = 0;
2367   swig_callbackOnWheelEvent = 0;
2368   swig_callbackOnRelayout = 0;
2369   swig_callbackOnSetResizePolicy = 0;
2370   swig_callbackGetNaturalSize = 0;
2371   swig_callbackCalculateChildSize = 0;
2372   swig_callbackGetHeightForWidth = 0;
2373   swig_callbackGetWidthForHeight = 0;
2374   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2375   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2376   swig_callbackOnCalculateRelayoutSize = 0;
2377   swig_callbackOnLayoutNegotiated = 0;
2378   swig_callbackOnInitialize = 0;
2379   swig_callbackOnStyleChange = 0;
2380   swig_callbackOnAccessibilityActivated = 0;
2381   swig_callbackOnAccessibilityPan = 0;
2382   swig_callbackOnAccessibilityValueChange = 0;
2383   swig_callbackOnAccessibilityZoom = 0;
2384   swig_callbackOnKeyInputFocusGained = 0;
2385   swig_callbackOnKeyInputFocusLost = 0;
2386   swig_callbackGetNextKeyboardFocusableActor = 0;
2387   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2388   swig_callbackOnKeyboardEnter = 0;
2389   swig_callbackOnPinch = 0;
2390   swig_callbackOnPan = 0;
2391   swig_callbackOnTap = 0;
2392   swig_callbackOnLongPress = 0;
2393   swig_callbackSignalConnected = 0;
2394   swig_callbackSignalDisconnected = 0;
2395 }
2396
2397 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2398   swig_init_callbacks();
2399 }
2400
2401 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2402
2403 }
2404
2405
2406 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2407   unsigned int c_result = SwigValueInit< unsigned int >() ;
2408   unsigned int jresult = 0 ;
2409
2410   if (!swig_callbackGetNumberOfItems) {
2411     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2412   } else {
2413     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2414     c_result = (unsigned int)jresult;
2415   }
2416   return c_result;
2417 }
2418
2419 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2420   Dali::Actor c_result ;
2421   void * jresult = 0 ;
2422   unsigned int jitemId  ;
2423
2424   if (!swig_callbackNewItem) {
2425     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2426   } else {
2427     jitemId = itemId;
2428     jresult = (void *) swig_callbackNewItem(jitemId);
2429     if (!jresult) {
2430       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2431       return c_result;
2432     }
2433     c_result = *(Dali::Actor *)jresult;
2434   }
2435   return c_result;
2436 }
2437
2438 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2439   unsigned int jitemId  ;
2440   void * jactor  ;
2441
2442   if (!swig_callbackItemReleased) {
2443     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2444     return;
2445   } else {
2446     jitemId = itemId;
2447     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2448     swig_callbackItemReleased(jitemId, jactor);
2449   }
2450 }
2451
2452 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2453   return Dali::Toolkit::ItemFactory::GetExtension();
2454 }
2455
2456 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2457   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2458   swig_callbackNewItem = callbackNewItem;
2459   swig_callbackItemReleased = callbackItemReleased;
2460 }
2461
2462 void SwigDirector_ItemFactory::swig_init_callbacks() {
2463   swig_callbackGetNumberOfItems = 0;
2464   swig_callbackNewItem = 0;
2465   swig_callbackItemReleased = 0;
2466 }
2467
2468 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2469   swig_init_callbacks();
2470 }
2471
2472 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2473
2474 }
2475
2476
2477 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2478   Dali::Actor c_result ;
2479   void * jresult = 0 ;
2480   void * jcurrent  ;
2481   void * jproposed  ;
2482   int jdirection  ;
2483
2484   if (!swig_callbackGetNextFocusableActor) {
2485     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2486   } else {
2487     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2488     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2489     jdirection = (int)direction;
2490     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2491     if (!jresult) {
2492       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__);
2493       return c_result;
2494     }
2495     c_result = *(Dali::Actor *)jresult;
2496   }
2497   return c_result;
2498 }
2499
2500 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2501   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2502 }
2503
2504 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2505   swig_callbackGetNextFocusableActor = 0;
2506 }
2507
2508 SwigDirector_FrameCallbackInterface::SwigDirector_FrameCallbackInterface() : Dali::FrameCallbackInterface(), Swig::Director() {
2509   swig_callbackOnUpdate = 0;
2510 }
2511
2512 SwigDirector_FrameCallbackInterface::~SwigDirector_FrameCallbackInterface() {
2513
2514 }
2515
2516 void SwigDirector_FrameCallbackInterface::swig_connect_director(SWIG_Callback0_t callbackUpdate) {
2517   swig_callbackOnUpdate = callbackUpdate;
2518 }
2519
2520
2521 void SwigDirector_FrameCallbackInterface::Update(Dali::UpdateProxy& updateProxy, float elapsedSeconds) {
2522   void * jcurrent  ;
2523
2524   if (!swig_callbackOnUpdate) {
2525     throw Swig::DirectorPureVirtualException("Dali::FrameCallbackInterface::Update");
2526   } else {
2527     Dali::UpdateProxy* proxy = &updateProxy;
2528     jcurrent = (void *)proxy;
2529     swig_callbackOnUpdate(jcurrent, elapsedSeconds);
2530     if (!jcurrent) {
2531       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::UpdateProxy! ", __FILE__, __LINE__);
2532       return;
2533     }
2534   }
2535   return;
2536 }
2537
2538
2539 #ifdef __cplusplus
2540 extern "C" {
2541 #endif
2542
2543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2544   void * jresult ;
2545   floatp *result = 0 ;
2546
2547   {
2548     try {
2549       result = (floatp *)new_floatp();
2550     } catch (std::out_of_range& e) {
2551       {
2552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2553       };
2554     } catch (std::exception& e) {
2555       {
2556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2557       };
2558     } catch (DaliException e) {
2559       {
2560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2561       };
2562     } catch (...) {
2563       {
2564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2565       };
2566     }
2567   }
2568   jresult = (void *)result;
2569   return jresult;
2570 }
2571
2572
2573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2574   floatp *arg1 = (floatp *) 0 ;
2575
2576   arg1 = (floatp *)jarg1;
2577   {
2578     try {
2579       delete_floatp(arg1);
2580     } catch (std::out_of_range& e) {
2581       {
2582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2583       };
2584     } catch (std::exception& e) {
2585       {
2586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2587       };
2588     } catch (Dali::DaliException e) {
2589       {
2590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2591       };
2592     } catch (...) {
2593       {
2594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2595       };
2596     }
2597   }
2598
2599 }
2600
2601
2602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2603   floatp *arg1 = (floatp *) 0 ;
2604   float arg2 ;
2605
2606   arg1 = (floatp *)jarg1;
2607   arg2 = (float)jarg2;
2608   {
2609     try {
2610       floatp_assign(arg1,arg2);
2611     } catch (std::out_of_range& e) {
2612       {
2613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2614       };
2615     } catch (std::exception& e) {
2616       {
2617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2618       };
2619     } catch (Dali::DaliException e) {
2620       {
2621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2622       };
2623     } catch (...) {
2624       {
2625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2626       };
2627     }
2628   }
2629
2630 }
2631
2632
2633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2634   float jresult ;
2635   floatp *arg1 = (floatp *) 0 ;
2636   float result;
2637
2638   arg1 = (floatp *)jarg1;
2639   {
2640     try {
2641       result = (float)floatp_value(arg1);
2642     } catch (std::out_of_range& e) {
2643       {
2644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2645       };
2646     } catch (std::exception& e) {
2647       {
2648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2649       };
2650     } catch (DaliException e) {
2651       {
2652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2653       };
2654     } catch (...) {
2655       {
2656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2657       };
2658     }
2659   }
2660   jresult = result;
2661   return jresult;
2662 }
2663
2664
2665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2666   void * jresult ;
2667   floatp *arg1 = (floatp *) 0 ;
2668   float *result = 0 ;
2669
2670   arg1 = (floatp *)jarg1;
2671   {
2672     try {
2673       result = (float *)floatp_cast(arg1);
2674     } catch (std::out_of_range& e) {
2675       {
2676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2677       };
2678     } catch (std::exception& e) {
2679       {
2680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2681       };
2682     } catch (Dali::DaliException e) {
2683       {
2684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2685       };
2686     } catch (...) {
2687       {
2688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2689       };
2690     }
2691   }
2692
2693   jresult = (void *)result;
2694   return jresult;
2695 }
2696
2697
2698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2699   void * jresult ;
2700   float *arg1 = (float *) 0 ;
2701   floatp *result = 0 ;
2702
2703   arg1 = (float *)jarg1;
2704   {
2705     try {
2706       result = (floatp *)floatp_frompointer(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_new_intp() {
2732   void * jresult ;
2733   intp *result = 0 ;
2734
2735   {
2736     try {
2737       result = (intp *)new_intp();
2738     } catch (std::out_of_range& e) {
2739       {
2740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2741       };
2742     } catch (std::exception& e) {
2743       {
2744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2745       };
2746     } catch (Dali::DaliException e) {
2747       {
2748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2749       };
2750     } catch (...) {
2751       {
2752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2753       };
2754     }
2755   }
2756
2757   jresult = (void *)result;
2758   return jresult;
2759 }
2760
2761
2762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2763   intp *arg1 = (intp *) 0 ;
2764
2765   arg1 = (intp *)jarg1;
2766   {
2767     try {
2768       delete_intp(arg1);
2769     } catch (std::out_of_range& e) {
2770       {
2771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2772       };
2773     } catch (std::exception& e) {
2774       {
2775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2776       };
2777     } catch (Dali::DaliException e) {
2778       {
2779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2780       };
2781     } catch (...) {
2782       {
2783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2784       };
2785     }
2786   }
2787
2788 }
2789
2790
2791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2792   intp *arg1 = (intp *) 0 ;
2793   int arg2 ;
2794
2795   arg1 = (intp *)jarg1;
2796   arg2 = (int)jarg2;
2797   {
2798     try {
2799       intp_assign(arg1,arg2);
2800     } catch (std::out_of_range& e) {
2801       {
2802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2803       };
2804     } catch (std::exception& e) {
2805       {
2806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2807       };
2808     } catch (Dali::DaliException e) {
2809       {
2810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2811       };
2812     } catch (...) {
2813       {
2814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2815       };
2816     }
2817   }
2818
2819 }
2820
2821
2822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2823   int jresult ;
2824   intp *arg1 = (intp *) 0 ;
2825   int result;
2826
2827   arg1 = (intp *)jarg1;
2828   {
2829     try {
2830       result = (int)intp_value(arg1);
2831     } catch (std::out_of_range& e) {
2832       {
2833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2834       };
2835     } catch (std::exception& e) {
2836       {
2837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2838       };
2839     } catch (Dali::DaliException e) {
2840       {
2841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2842       };
2843     } catch (...) {
2844       {
2845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2846       };
2847     }
2848   }
2849
2850   jresult = result;
2851   return jresult;
2852 }
2853
2854
2855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2856   void * jresult ;
2857   intp *arg1 = (intp *) 0 ;
2858   int *result = 0 ;
2859
2860   arg1 = (intp *)jarg1;
2861   {
2862     try {
2863       result = (int *)intp_cast(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 = (void *)result;
2884   return jresult;
2885 }
2886
2887
2888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2889   void * jresult ;
2890   int *arg1 = (int *) 0 ;
2891   intp *result = 0 ;
2892
2893   arg1 = (int *)jarg1;
2894   {
2895     try {
2896       result = (intp *)intp_frompointer(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_new_doublep() {
2922   void * jresult ;
2923   doublep *result = 0 ;
2924
2925   {
2926     try {
2927       result = (doublep *)new_doublep();
2928     } catch (std::out_of_range& e) {
2929       {
2930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2931       };
2932     } catch (std::exception& e) {
2933       {
2934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2935       };
2936     } catch (Dali::DaliException e) {
2937       {
2938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2939       };
2940     } catch (...) {
2941       {
2942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2943       };
2944     }
2945   }
2946
2947   jresult = (void *)result;
2948   return jresult;
2949 }
2950
2951
2952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2953   doublep *arg1 = (doublep *) 0 ;
2954
2955   arg1 = (doublep *)jarg1;
2956   {
2957     try {
2958       delete_doublep(arg1);
2959     } catch (std::out_of_range& e) {
2960       {
2961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2962       };
2963     } catch (std::exception& e) {
2964       {
2965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2966       };
2967     } catch (Dali::DaliException e) {
2968       {
2969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2970       };
2971     } catch (...) {
2972       {
2973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2974       };
2975     }
2976   }
2977
2978 }
2979
2980
2981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2982   doublep *arg1 = (doublep *) 0 ;
2983   double arg2 ;
2984
2985   arg1 = (doublep *)jarg1;
2986   arg2 = (double)jarg2;
2987   {
2988     try {
2989       doublep_assign(arg1,arg2);
2990     } catch (std::out_of_range& e) {
2991       {
2992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2993       };
2994     } catch (std::exception& e) {
2995       {
2996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2997       };
2998     } catch (Dali::DaliException e) {
2999       {
3000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3001       };
3002     } catch (...) {
3003       {
3004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3005       };
3006     }
3007   }
3008
3009 }
3010
3011
3012 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3013   double jresult ;
3014   doublep *arg1 = (doublep *) 0 ;
3015   double result;
3016
3017   arg1 = (doublep *)jarg1;
3018   {
3019     try {
3020       result = (double)doublep_value(arg1);
3021     } catch (std::out_of_range& e) {
3022       {
3023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3024       };
3025     } catch (std::exception& e) {
3026       {
3027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3028       };
3029     } catch (Dali::DaliException e) {
3030       {
3031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3032       };
3033     } catch (...) {
3034       {
3035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3036       };
3037     }
3038   }
3039
3040   jresult = result;
3041   return jresult;
3042 }
3043
3044
3045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3046   void * jresult ;
3047   doublep *arg1 = (doublep *) 0 ;
3048   double *result = 0 ;
3049
3050   arg1 = (doublep *)jarg1;
3051   {
3052     try {
3053       result = (double *)doublep_cast(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 = (void *)result;
3074   return jresult;
3075 }
3076
3077
3078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3079   void * jresult ;
3080   double *arg1 = (double *) 0 ;
3081   doublep *result = 0 ;
3082
3083   arg1 = (double *)jarg1;
3084   {
3085     try {
3086       result = (doublep *)doublep_frompointer(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_new_uintp() {
3112   void * jresult ;
3113   uintp *result = 0 ;
3114
3115   {
3116     try {
3117       result = (uintp *)new_uintp();
3118     } catch (std::out_of_range& e) {
3119       {
3120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3121       };
3122     } catch (std::exception& e) {
3123       {
3124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3125       };
3126     } catch (Dali::DaliException e) {
3127       {
3128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3129       };
3130     } catch (...) {
3131       {
3132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3133       };
3134     }
3135   }
3136
3137   jresult = (void *)result;
3138   return jresult;
3139 }
3140
3141
3142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3143   uintp *arg1 = (uintp *) 0 ;
3144
3145   arg1 = (uintp *)jarg1;
3146   {
3147     try {
3148       delete_uintp(arg1);
3149     } catch (std::out_of_range& e) {
3150       {
3151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3152       };
3153     } catch (std::exception& e) {
3154       {
3155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3156       };
3157     } catch (Dali::DaliException e) {
3158       {
3159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3160       };
3161     } catch (...) {
3162       {
3163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3164       };
3165     }
3166   }
3167
3168 }
3169
3170
3171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3172   uintp *arg1 = (uintp *) 0 ;
3173   unsigned int arg2 ;
3174
3175   arg1 = (uintp *)jarg1;
3176   arg2 = (unsigned int)jarg2;
3177   {
3178     try {
3179       uintp_assign(arg1,arg2);
3180     } catch (std::out_of_range& e) {
3181       {
3182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3183       };
3184     } catch (std::exception& e) {
3185       {
3186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3187       };
3188     } catch (Dali::DaliException e) {
3189       {
3190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3191       };
3192     } catch (...) {
3193       {
3194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3195       };
3196     }
3197   }
3198
3199 }
3200
3201
3202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3203   unsigned int jresult ;
3204   uintp *arg1 = (uintp *) 0 ;
3205   unsigned int result;
3206
3207   arg1 = (uintp *)jarg1;
3208   {
3209     try {
3210       result = (unsigned int)uintp_value(arg1);
3211     } catch (std::out_of_range& e) {
3212       {
3213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3214       };
3215     } catch (std::exception& e) {
3216       {
3217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3218       };
3219     } catch (Dali::DaliException e) {
3220       {
3221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3222       };
3223     } catch (...) {
3224       {
3225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3226       };
3227     }
3228   }
3229
3230   jresult = result;
3231   return jresult;
3232 }
3233
3234
3235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3236   void * jresult ;
3237   uintp *arg1 = (uintp *) 0 ;
3238   unsigned int *result = 0 ;
3239
3240   arg1 = (uintp *)jarg1;
3241   {
3242     try {
3243       result = (unsigned int *)uintp_cast(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 = (void *)result;
3264   return jresult;
3265 }
3266
3267
3268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3269   void * jresult ;
3270   unsigned int *arg1 = (unsigned int *) 0 ;
3271   uintp *result = 0 ;
3272
3273   arg1 = (unsigned int *)jarg1;
3274   {
3275     try {
3276       result = (uintp *)uintp_frompointer(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_new_ushortp() {
3302   void * jresult ;
3303   ushortp *result = 0 ;
3304
3305   {
3306     try {
3307       result = (ushortp *)new_ushortp();
3308     } catch (std::out_of_range& e) {
3309       {
3310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3311       };
3312     } catch (std::exception& e) {
3313       {
3314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3315       };
3316     } catch (Dali::DaliException e) {
3317       {
3318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3319       };
3320     } catch (...) {
3321       {
3322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3323       };
3324     }
3325   }
3326
3327   jresult = (void *)result;
3328   return jresult;
3329 }
3330
3331
3332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3333   ushortp *arg1 = (ushortp *) 0 ;
3334
3335   arg1 = (ushortp *)jarg1;
3336   {
3337     try {
3338       delete_ushortp(arg1);
3339     } catch (std::out_of_range& e) {
3340       {
3341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3342       };
3343     } catch (std::exception& e) {
3344       {
3345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3346       };
3347     } catch (Dali::DaliException e) {
3348       {
3349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3350       };
3351     } catch (...) {
3352       {
3353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3354       };
3355     }
3356   }
3357
3358 }
3359
3360
3361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3362   ushortp *arg1 = (ushortp *) 0 ;
3363   unsigned short arg2 ;
3364
3365   arg1 = (ushortp *)jarg1;
3366   arg2 = (unsigned short)jarg2;
3367   {
3368     try {
3369       ushortp_assign(arg1,arg2);
3370     } catch (std::out_of_range& e) {
3371       {
3372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3373       };
3374     } catch (std::exception& e) {
3375       {
3376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3377       };
3378     } catch (Dali::DaliException e) {
3379       {
3380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3381       };
3382     } catch (...) {
3383       {
3384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3385       };
3386     }
3387   }
3388
3389 }
3390
3391
3392 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3393   unsigned short jresult ;
3394   ushortp *arg1 = (ushortp *) 0 ;
3395   unsigned short result;
3396
3397   arg1 = (ushortp *)jarg1;
3398   {
3399     try {
3400       result = (unsigned short)ushortp_value(arg1);
3401     } catch (std::out_of_range& e) {
3402       {
3403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3404       };
3405     } catch (std::exception& e) {
3406       {
3407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3408       };
3409     } catch (Dali::DaliException e) {
3410       {
3411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3412       };
3413     } catch (...) {
3414       {
3415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3416       };
3417     }
3418   }
3419
3420   jresult = result;
3421   return jresult;
3422 }
3423
3424
3425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3426   void * jresult ;
3427   ushortp *arg1 = (ushortp *) 0 ;
3428   unsigned short *result = 0 ;
3429
3430   arg1 = (ushortp *)jarg1;
3431   {
3432     try {
3433       result = (unsigned short *)ushortp_cast(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 = (void *)result;
3454   return jresult;
3455 }
3456
3457
3458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3459   void * jresult ;
3460   unsigned short *arg1 = (unsigned short *) 0 ;
3461   ushortp *result = 0 ;
3462
3463   arg1 = (unsigned short *)jarg1;
3464   {
3465     try {
3466       result = (ushortp *)ushortp_frompointer(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 unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3492   unsigned int jresult ;
3493   int arg1 ;
3494   unsigned int result;
3495
3496   arg1 = (int)jarg1;
3497   {
3498     try {
3499       result = (unsigned int)int_to_uint(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 = result;
3520   return jresult;
3521 }
3522
3523
3524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3525   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3526
3527   arg1 = (Dali::RefObject *)jarg1;
3528   {
3529     try {
3530       (arg1)->Reference();
3531     } catch (std::out_of_range& e) {
3532       {
3533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3534       };
3535     } catch (std::exception& e) {
3536       {
3537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3538       };
3539     } catch (Dali::DaliException e) {
3540       {
3541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3542       };
3543     } catch (...) {
3544       {
3545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3546       };
3547     }
3548   }
3549
3550 }
3551
3552
3553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3554   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3555
3556   arg1 = (Dali::RefObject *)jarg1;
3557   {
3558     try {
3559       (arg1)->Unreference();
3560     } catch (std::out_of_range& e) {
3561       {
3562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3563       };
3564     } catch (std::exception& e) {
3565       {
3566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3567       };
3568     } catch (Dali::DaliException e) {
3569       {
3570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3571       };
3572     } catch (...) {
3573       {
3574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3575       };
3576     }
3577   }
3578
3579 }
3580
3581
3582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3583   int jresult ;
3584   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3585   int result;
3586
3587   arg1 = (Dali::RefObject *)jarg1;
3588   {
3589     try {
3590       result = (int)(arg1)->ReferenceCount();
3591     } catch (std::out_of_range& e) {
3592       {
3593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3594       };
3595     } catch (std::exception& e) {
3596       {
3597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3598       };
3599     } catch (Dali::DaliException e) {
3600       {
3601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3602       };
3603     } catch (...) {
3604       {
3605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3606       };
3607     }
3608   }
3609
3610   jresult = result;
3611   return jresult;
3612 }
3613
3614
3615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3616   void * jresult ;
3617   Dali::Any *result = 0 ;
3618
3619   {
3620     try {
3621       result = (Dali::Any *)new Dali::Any();
3622     } catch (std::out_of_range& e) {
3623       {
3624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3625       };
3626     } catch (std::exception& e) {
3627       {
3628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3629       };
3630     } catch (Dali::DaliException e) {
3631       {
3632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3633       };
3634     } catch (...) {
3635       {
3636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3637       };
3638     }
3639   }
3640
3641   jresult = (void *)result;
3642   return jresult;
3643 }
3644
3645
3646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3647   Dali::Any *arg1 = (Dali::Any *) 0 ;
3648
3649   arg1 = (Dali::Any *)jarg1;
3650   {
3651     try {
3652       delete arg1;
3653     } catch (std::out_of_range& e) {
3654       {
3655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3656       };
3657     } catch (std::exception& e) {
3658       {
3659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3660       };
3661     } catch (Dali::DaliException e) {
3662       {
3663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3664       };
3665     } catch (...) {
3666       {
3667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3668       };
3669     }
3670   }
3671
3672 }
3673
3674
3675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3676   char *arg1 = (char *) 0 ;
3677
3678   arg1 = (char *)jarg1;
3679   {
3680     try {
3681       Dali::Any::AssertAlways((char const *)arg1);
3682     } catch (std::out_of_range& e) {
3683       {
3684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3685       };
3686     } catch (std::exception& e) {
3687       {
3688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3689       };
3690     } catch (Dali::DaliException e) {
3691       {
3692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3693       };
3694     } catch (...) {
3695       {
3696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3697       };
3698     }
3699   }
3700
3701 }
3702
3703
3704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3705   void * jresult ;
3706   Dali::Any *arg1 = 0 ;
3707   Dali::Any *result = 0 ;
3708
3709   arg1 = (Dali::Any *)jarg1;
3710   if (!arg1) {
3711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3712     return 0;
3713   }
3714   {
3715     try {
3716       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3717     } catch (std::out_of_range& e) {
3718       {
3719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3720       };
3721     } catch (std::exception& e) {
3722       {
3723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3724       };
3725     } catch (Dali::DaliException e) {
3726       {
3727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3728       };
3729     } catch (...) {
3730       {
3731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3732       };
3733     }
3734   }
3735
3736   jresult = (void *)result;
3737   return jresult;
3738 }
3739
3740
3741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3742   void * jresult ;
3743   Dali::Any *arg1 = (Dali::Any *) 0 ;
3744   Dali::Any *arg2 = 0 ;
3745   Dali::Any *result = 0 ;
3746
3747   arg1 = (Dali::Any *)jarg1;
3748   arg2 = (Dali::Any *)jarg2;
3749   if (!arg2) {
3750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3751     return 0;
3752   }
3753   {
3754     try {
3755       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3756     } catch (std::out_of_range& e) {
3757       {
3758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3759       };
3760     } catch (std::exception& e) {
3761       {
3762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3763       };
3764     } catch (Dali::DaliException e) {
3765       {
3766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3767       };
3768     } catch (...) {
3769       {
3770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3771       };
3772     }
3773   }
3774
3775   jresult = (void *)result;
3776   return jresult;
3777 }
3778
3779
3780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3781   void * jresult ;
3782   Dali::Any *arg1 = (Dali::Any *) 0 ;
3783   std::type_info *result = 0 ;
3784
3785   arg1 = (Dali::Any *)jarg1;
3786   {
3787     try {
3788       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
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 unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3814   unsigned int jresult ;
3815   Dali::Any *arg1 = (Dali::Any *) 0 ;
3816   bool result;
3817
3818   arg1 = (Dali::Any *)jarg1;
3819   {
3820     try {
3821       result = (bool)((Dali::Any const *)arg1)->Empty();
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 = result;
3842   return jresult;
3843 }
3844
3845
3846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3847   void * jresult ;
3848   std::type_info *arg1 = 0 ;
3849   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3850   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3851   Dali::Any::AnyContainerBase *result = 0 ;
3852
3853   arg1 = (std::type_info *)jarg1;
3854   if (!arg1) {
3855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3856     return 0;
3857   }
3858   arg2 = (Dali::Any::CloneFunc)jarg2;
3859   arg3 = (Dali::Any::DeleteFunc)jarg3;
3860   {
3861     try {
3862       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3863     } catch (std::out_of_range& e) {
3864       {
3865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3866       };
3867     } catch (std::exception& e) {
3868       {
3869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3870       };
3871     } catch (Dali::DaliException e) {
3872       {
3873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3874       };
3875     } catch (...) {
3876       {
3877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3878       };
3879     }
3880   }
3881
3882   jresult = (void *)result;
3883   return jresult;
3884 }
3885
3886
3887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3888   void * jresult ;
3889   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3890   std::type_info *result = 0 ;
3891
3892   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3893   {
3894     try {
3895       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
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_mType_get(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   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3927   jresult = (void *)result;
3928   return jresult;
3929 }
3930
3931
3932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3933   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3934   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3935
3936   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3937   arg2 = (Dali::Any::CloneFunc)jarg2;
3938   if (arg1) (arg1)->mCloneFunc = arg2;
3939 }
3940
3941
3942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3943   void * jresult ;
3944   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3945   Dali::Any::CloneFunc result;
3946
3947   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3948   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3949   jresult = (void *)result;
3950   return jresult;
3951 }
3952
3953
3954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3955   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3956   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3957
3958   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3959   arg2 = (Dali::Any::DeleteFunc)jarg2;
3960   if (arg1) (arg1)->mDeleteFunc = arg2;
3961 }
3962
3963
3964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3965   void * jresult ;
3966   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3967   Dali::Any::DeleteFunc result;
3968
3969   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3970   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3971   jresult = (void *)result;
3972   return jresult;
3973 }
3974
3975
3976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3977   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3978
3979   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3980   {
3981     try {
3982       delete arg1;
3983     } catch (std::out_of_range& e) {
3984       {
3985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3986       };
3987     } catch (std::exception& e) {
3988       {
3989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3990       };
3991     } catch (Dali::DaliException e) {
3992       {
3993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3994       };
3995     } catch (...) {
3996       {
3997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3998       };
3999     }
4000   }
4001
4002 }
4003
4004
4005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4006   Dali::Any *arg1 = (Dali::Any *) 0 ;
4007   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4008
4009   arg1 = (Dali::Any *)jarg1;
4010   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4011   if (arg1) (arg1)->mContainer = arg2;
4012 }
4013
4014
4015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4016   void * jresult ;
4017   Dali::Any *arg1 = (Dali::Any *) 0 ;
4018   Dali::Any::AnyContainerBase *result = 0 ;
4019
4020   arg1 = (Dali::Any *)jarg1;
4021   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4022   jresult = (void *)result;
4023   return jresult;
4024 }
4025
4026
4027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4028   char *arg1 = (char *) 0 ;
4029   char *arg2 = (char *) 0 ;
4030
4031   arg1 = (char *)jarg1;
4032   arg2 = (char *)jarg2;
4033   {
4034     try {
4035       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4036     } catch (std::out_of_range& e) {
4037       {
4038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4039       };
4040     } catch (std::exception& e) {
4041       {
4042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4043       };
4044     } catch (Dali::DaliException e) {
4045       {
4046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4047       };
4048     } catch (...) {
4049       {
4050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4051       };
4052     }
4053   }
4054
4055 }
4056
4057
4058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4059   void * jresult ;
4060   char *arg1 = (char *) 0 ;
4061   char *arg2 = (char *) 0 ;
4062   Dali::DaliException *result = 0 ;
4063
4064   arg1 = (char *)jarg1;
4065   arg2 = (char *)jarg2;
4066   {
4067     try {
4068       result = (Dali::DaliException *)new Dali::DaliException((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 0;
4072       };
4073     } catch (std::exception& e) {
4074       {
4075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4076       };
4077     } catch (Dali::DaliException e) {
4078       {
4079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4080       };
4081     } catch (...) {
4082       {
4083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4084       };
4085     }
4086   }
4087
4088   jresult = (void *)result;
4089   return jresult;
4090 }
4091
4092
4093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4094   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4095   std::string arg2 = std::string(jarg2);
4096
4097   arg1 = (Dali::DaliException *)jarg1;
4098   {
4099     if (!arg2.empty()) {
4100       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4101     } else {
4102       arg1->location = 0;
4103     }
4104   }
4105 }
4106
4107 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4108   char * jresult ;
4109   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4110   char *result = 0 ;
4111
4112   arg1 = (Dali::DaliException *)jarg1;
4113   result = (char *) ((arg1)->location);
4114   jresult = SWIG_csharp_string_callback((const char *)result);
4115   return jresult;
4116 }
4117
4118
4119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4120   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4121   std::string arg2 = std::string(jarg2);
4122
4123   arg1 = (Dali::DaliException *)jarg1;
4124   {
4125     if (!arg2.empty()) {
4126       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4127     } else {
4128       arg1->condition = 0;
4129     }
4130   }
4131 }
4132
4133
4134 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4135   char * jresult ;
4136   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4137   char *result = 0 ;
4138
4139   arg1 = (Dali::DaliException *)jarg1;
4140   result = (char *) ((arg1)->condition);
4141   jresult = SWIG_csharp_string_callback((const char *)result);
4142   return jresult;
4143 }
4144
4145
4146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4147   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4148
4149   arg1 = (Dali::DaliException *)jarg1;
4150   {
4151     try {
4152       delete arg1;
4153     } catch (std::out_of_range& e) {
4154       {
4155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4156       };
4157     } catch (std::exception& e) {
4158       {
4159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4160       };
4161     } catch (Dali::DaliException e) {
4162       {
4163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4164       };
4165     } catch (...) {
4166       {
4167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4168       };
4169     }
4170   }
4171
4172 }
4173
4174
4175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4176   void * jresult ;
4177   Dali::Vector2 *result = 0 ;
4178
4179   {
4180     try {
4181       result = (Dali::Vector2 *)new Dali::Vector2();
4182     } catch (std::out_of_range& e) {
4183       {
4184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4185       };
4186     } catch (std::exception& e) {
4187       {
4188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4189       };
4190     } catch (Dali::DaliException e) {
4191       {
4192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4193       };
4194     } catch (...) {
4195       {
4196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4197       };
4198     }
4199   }
4200
4201   jresult = (void *)result;
4202   return jresult;
4203 }
4204
4205
4206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4207   void * jresult ;
4208   float arg1 ;
4209   float arg2 ;
4210   Dali::Vector2 *result = 0 ;
4211
4212   arg1 = (float)jarg1;
4213   arg2 = (float)jarg2;
4214   {
4215     try {
4216       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4217     } catch (std::out_of_range& e) {
4218       {
4219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4220       };
4221     } catch (std::exception& e) {
4222       {
4223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4224       };
4225     } catch (Dali::DaliException e) {
4226       {
4227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4228       };
4229     } catch (...) {
4230       {
4231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4232       };
4233     }
4234   }
4235
4236   jresult = (void *)result;
4237   return jresult;
4238 }
4239
4240
4241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4242   void * jresult ;
4243   float *arg1 = (float *) 0 ;
4244   Dali::Vector2 *result = 0 ;
4245
4246   arg1 = jarg1;
4247   {
4248     try {
4249       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
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
4271
4272   return jresult;
4273 }
4274
4275
4276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4277   void * jresult ;
4278   Dali::Vector3 *arg1 = 0 ;
4279   Dali::Vector2 *result = 0 ;
4280
4281   arg1 = (Dali::Vector3 *)jarg1;
4282   if (!arg1) {
4283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4284     return 0;
4285   }
4286   {
4287     try {
4288       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4289     } catch (std::out_of_range& e) {
4290       {
4291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4292       };
4293     } catch (std::exception& e) {
4294       {
4295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4296       };
4297     } catch (Dali::DaliException e) {
4298       {
4299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4300       };
4301     } catch (...) {
4302       {
4303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4304       };
4305     }
4306   }
4307
4308   jresult = (void *)result;
4309   return jresult;
4310 }
4311
4312
4313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4314   void * jresult ;
4315   Dali::Vector4 *arg1 = 0 ;
4316   Dali::Vector2 *result = 0 ;
4317
4318   arg1 = (Dali::Vector4 *)jarg1;
4319   if (!arg1) {
4320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4321     return 0;
4322   }
4323   {
4324     try {
4325       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4326     } catch (std::out_of_range& e) {
4327       {
4328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4329       };
4330     } catch (std::exception& e) {
4331       {
4332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4333       };
4334     } catch (Dali::DaliException e) {
4335       {
4336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4337       };
4338     } catch (...) {
4339       {
4340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4341       };
4342     }
4343   }
4344
4345   jresult = (void *)result;
4346   return jresult;
4347 }
4348
4349
4350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4351   void * jresult ;
4352   Dali::Vector2 *result = 0 ;
4353
4354   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4355   jresult = (void *)result;
4356   return jresult;
4357 }
4358
4359
4360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4361   void * jresult ;
4362   Dali::Vector2 *result = 0 ;
4363
4364   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4365   jresult = (void *)result;
4366   return jresult;
4367 }
4368
4369
4370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4371   void * jresult ;
4372   Dali::Vector2 *result = 0 ;
4373
4374   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4375   jresult = (void *)result;
4376   return jresult;
4377 }
4378
4379
4380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4381   void * jresult ;
4382   Dali::Vector2 *result = 0 ;
4383
4384   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4385   jresult = (void *)result;
4386   return jresult;
4387 }
4388
4389
4390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4391   void * jresult ;
4392   Dali::Vector2 *result = 0 ;
4393
4394   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4395   jresult = (void *)result;
4396   return jresult;
4397 }
4398
4399
4400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4401   void * jresult ;
4402   Dali::Vector2 *result = 0 ;
4403
4404   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4405   jresult = (void *)result;
4406   return jresult;
4407 }
4408
4409
4410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4411   void * jresult ;
4412   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4413   float *arg2 = (float *) 0 ;
4414   Dali::Vector2 *result = 0 ;
4415
4416   arg1 = (Dali::Vector2 *)jarg1;
4417   arg2 = jarg2;
4418   {
4419     try {
4420       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4421     } catch (std::out_of_range& e) {
4422       {
4423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4424       };
4425     } catch (std::exception& e) {
4426       {
4427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4428       };
4429     } catch (Dali::DaliException e) {
4430       {
4431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4432       };
4433     } catch (...) {
4434       {
4435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4436       };
4437     }
4438   }
4439
4440   jresult = (void *)result;
4441
4442
4443   return jresult;
4444 }
4445
4446
4447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4448   void * jresult ;
4449   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4450   Dali::Vector3 *arg2 = 0 ;
4451   Dali::Vector2 *result = 0 ;
4452
4453   arg1 = (Dali::Vector2 *)jarg1;
4454   arg2 = (Dali::Vector3 *)jarg2;
4455   if (!arg2) {
4456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4457     return 0;
4458   }
4459   {
4460     try {
4461       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4462     } catch (std::out_of_range& e) {
4463       {
4464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4465       };
4466     } catch (std::exception& e) {
4467       {
4468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4469       };
4470     } catch (Dali::DaliException e) {
4471       {
4472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4473       };
4474     } catch (...) {
4475       {
4476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4477       };
4478     }
4479   }
4480
4481   jresult = (void *)result;
4482   return jresult;
4483 }
4484
4485
4486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4487   void * jresult ;
4488   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4489   Dali::Vector4 *arg2 = 0 ;
4490   Dali::Vector2 *result = 0 ;
4491
4492   arg1 = (Dali::Vector2 *)jarg1;
4493   arg2 = (Dali::Vector4 *)jarg2;
4494   if (!arg2) {
4495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4496     return 0;
4497   }
4498   {
4499     try {
4500       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4501     } catch (std::out_of_range& e) {
4502       {
4503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4504       };
4505     } catch (std::exception& e) {
4506       {
4507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4508       };
4509     } catch (Dali::DaliException e) {
4510       {
4511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4512       };
4513     } catch (...) {
4514       {
4515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4516       };
4517     }
4518   }
4519
4520   jresult = (void *)result;
4521   return jresult;
4522 }
4523
4524
4525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4526   void * jresult ;
4527   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4528   Dali::Vector2 *arg2 = 0 ;
4529   Dali::Vector2 result;
4530
4531   arg1 = (Dali::Vector2 *)jarg1;
4532   arg2 = (Dali::Vector2 *)jarg2;
4533   if (!arg2) {
4534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4535     return 0;
4536   }
4537   {
4538     try {
4539       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4540     } catch (std::out_of_range& e) {
4541       {
4542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4543       };
4544     } catch (std::exception& e) {
4545       {
4546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4547       };
4548     } catch (Dali::DaliException e) {
4549       {
4550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4551       };
4552     } catch (...) {
4553       {
4554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4555       };
4556     }
4557   }
4558
4559   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4560   return jresult;
4561 }
4562
4563
4564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4565   void * jresult ;
4566   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4567   Dali::Vector2 *arg2 = 0 ;
4568   Dali::Vector2 *result = 0 ;
4569
4570   arg1 = (Dali::Vector2 *)jarg1;
4571   arg2 = (Dali::Vector2 *)jarg2;
4572   if (!arg2) {
4573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4574     return 0;
4575   }
4576   {
4577     try {
4578       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4579     } catch (std::out_of_range& e) {
4580       {
4581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4582       };
4583     } catch (std::exception& e) {
4584       {
4585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4586       };
4587     } catch (Dali::DaliException e) {
4588       {
4589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4590       };
4591     } catch (...) {
4592       {
4593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4594       };
4595     }
4596   }
4597
4598   jresult = (void *)result;
4599   return jresult;
4600 }
4601
4602
4603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4604   void * jresult ;
4605   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4606   Dali::Vector2 *arg2 = 0 ;
4607   Dali::Vector2 result;
4608
4609   arg1 = (Dali::Vector2 *)jarg1;
4610   arg2 = (Dali::Vector2 *)jarg2;
4611   if (!arg2) {
4612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4613     return 0;
4614   }
4615   {
4616     try {
4617       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4618     } catch (std::out_of_range& e) {
4619       {
4620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4621       };
4622     } catch (std::exception& e) {
4623       {
4624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4625       };
4626     } catch (Dali::DaliException e) {
4627       {
4628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4629       };
4630     } catch (...) {
4631       {
4632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4633       };
4634     }
4635   }
4636
4637   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4638   return jresult;
4639 }
4640
4641
4642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4643   void * jresult ;
4644   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4645   Dali::Vector2 *arg2 = 0 ;
4646   Dali::Vector2 *result = 0 ;
4647
4648   arg1 = (Dali::Vector2 *)jarg1;
4649   arg2 = (Dali::Vector2 *)jarg2;
4650   if (!arg2) {
4651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4652     return 0;
4653   }
4654   {
4655     try {
4656       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4657     } catch (std::out_of_range& e) {
4658       {
4659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4660       };
4661     } catch (std::exception& e) {
4662       {
4663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4664       };
4665     } catch (Dali::DaliException e) {
4666       {
4667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4668       };
4669     } catch (...) {
4670       {
4671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4672       };
4673     }
4674   }
4675
4676   jresult = (void *)result;
4677   return jresult;
4678 }
4679
4680
4681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4682   void * jresult ;
4683   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4684   Dali::Vector2 *arg2 = 0 ;
4685   Dali::Vector2 result;
4686
4687   arg1 = (Dali::Vector2 *)jarg1;
4688   arg2 = (Dali::Vector2 *)jarg2;
4689   if (!arg2) {
4690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4691     return 0;
4692   }
4693   {
4694     try {
4695       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4696     } catch (std::out_of_range& e) {
4697       {
4698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4699       };
4700     } catch (std::exception& e) {
4701       {
4702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4703       };
4704     } catch (Dali::DaliException e) {
4705       {
4706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4707       };
4708     } catch (...) {
4709       {
4710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4711       };
4712     }
4713   }
4714
4715   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4716   return jresult;
4717 }
4718
4719
4720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4721   void * jresult ;
4722   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4723   float arg2 ;
4724   Dali::Vector2 result;
4725
4726   arg1 = (Dali::Vector2 *)jarg1;
4727   arg2 = (float)jarg2;
4728   {
4729     try {
4730       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4731     } catch (std::out_of_range& e) {
4732       {
4733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4734       };
4735     } catch (std::exception& e) {
4736       {
4737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4738       };
4739     } catch (Dali::DaliException e) {
4740       {
4741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4742       };
4743     } catch (...) {
4744       {
4745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4746       };
4747     }
4748   }
4749
4750   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4751   return jresult;
4752 }
4753
4754
4755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4756   void * jresult ;
4757   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4758   Dali::Vector2 *arg2 = 0 ;
4759   Dali::Vector2 *result = 0 ;
4760
4761   arg1 = (Dali::Vector2 *)jarg1;
4762   arg2 = (Dali::Vector2 *)jarg2;
4763   if (!arg2) {
4764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4765     return 0;
4766   }
4767   {
4768     try {
4769       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4770     } catch (std::out_of_range& e) {
4771       {
4772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4773       };
4774     } catch (std::exception& e) {
4775       {
4776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4777       };
4778     } catch (Dali::DaliException e) {
4779       {
4780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4781       };
4782     } catch (...) {
4783       {
4784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4785       };
4786     }
4787   }
4788
4789   jresult = (void *)result;
4790   return jresult;
4791 }
4792
4793
4794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4795   void * jresult ;
4796   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4797   float arg2 ;
4798   Dali::Vector2 *result = 0 ;
4799
4800   arg1 = (Dali::Vector2 *)jarg1;
4801   arg2 = (float)jarg2;
4802   {
4803     try {
4804       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4805     } catch (std::out_of_range& e) {
4806       {
4807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4808       };
4809     } catch (std::exception& e) {
4810       {
4811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4812       };
4813     } catch (Dali::DaliException e) {
4814       {
4815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4816       };
4817     } catch (...) {
4818       {
4819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4820       };
4821     }
4822   }
4823
4824   jresult = (void *)result;
4825   return jresult;
4826 }
4827
4828
4829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4830   void * jresult ;
4831   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4832   Dali::Vector2 *arg2 = 0 ;
4833   Dali::Vector2 result;
4834
4835   arg1 = (Dali::Vector2 *)jarg1;
4836   arg2 = (Dali::Vector2 *)jarg2;
4837   if (!arg2) {
4838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4839     return 0;
4840   }
4841   {
4842     try {
4843       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4844     } catch (std::out_of_range& e) {
4845       {
4846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4847       };
4848     } catch (std::exception& e) {
4849       {
4850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4851       };
4852     } catch (Dali::DaliException e) {
4853       {
4854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4855       };
4856     } catch (...) {
4857       {
4858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4859       };
4860     }
4861   }
4862
4863   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4864   return jresult;
4865 }
4866
4867
4868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4869   void * jresult ;
4870   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4871   float arg2 ;
4872   Dali::Vector2 result;
4873
4874   arg1 = (Dali::Vector2 *)jarg1;
4875   arg2 = (float)jarg2;
4876   {
4877     try {
4878       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4879     } catch (std::out_of_range& e) {
4880       {
4881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4882       };
4883     } catch (std::exception& e) {
4884       {
4885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4886       };
4887     } catch (Dali::DaliException e) {
4888       {
4889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4890       };
4891     } catch (...) {
4892       {
4893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4894       };
4895     }
4896   }
4897
4898   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4899   return jresult;
4900 }
4901
4902
4903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4904   void * jresult ;
4905   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4906   Dali::Vector2 *arg2 = 0 ;
4907   Dali::Vector2 *result = 0 ;
4908
4909   arg1 = (Dali::Vector2 *)jarg1;
4910   arg2 = (Dali::Vector2 *)jarg2;
4911   if (!arg2) {
4912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4913     return 0;
4914   }
4915   {
4916     try {
4917       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4918     } catch (std::out_of_range& e) {
4919       {
4920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4921       };
4922     } catch (std::exception& e) {
4923       {
4924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4925       };
4926     } catch (Dali::DaliException e) {
4927       {
4928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4929       };
4930     } catch (...) {
4931       {
4932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4933       };
4934     }
4935   }
4936
4937   jresult = (void *)result;
4938   return jresult;
4939 }
4940
4941
4942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4943   void * jresult ;
4944   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4945   float arg2 ;
4946   Dali::Vector2 *result = 0 ;
4947
4948   arg1 = (Dali::Vector2 *)jarg1;
4949   arg2 = (float)jarg2;
4950   {
4951     try {
4952       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4953     } catch (std::out_of_range& e) {
4954       {
4955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4956       };
4957     } catch (std::exception& e) {
4958       {
4959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4960       };
4961     } catch (Dali::DaliException e) {
4962       {
4963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4964       };
4965     } catch (...) {
4966       {
4967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4968       };
4969     }
4970   }
4971
4972   jresult = (void *)result;
4973   return jresult;
4974 }
4975
4976
4977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4978   void * jresult ;
4979   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4980   Dali::Vector2 result;
4981
4982   arg1 = (Dali::Vector2 *)jarg1;
4983   {
4984     try {
4985       result = ((Dali::Vector2 const *)arg1)->operator -();
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 = new Dali::Vector2((const Dali::Vector2 &)result);
5006   return jresult;
5007 }
5008
5009
5010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5011   unsigned int jresult ;
5012   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5013   Dali::Vector2 *arg2 = 0 ;
5014   bool result;
5015
5016   arg1 = (Dali::Vector2 *)jarg1;
5017   arg2 = (Dali::Vector2 *)jarg2;
5018   if (!arg2) {
5019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5020     return 0;
5021   }
5022   {
5023     try {
5024       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5025     } catch (std::out_of_range& e) {
5026       {
5027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5028       };
5029     } catch (std::exception& e) {
5030       {
5031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5032       };
5033     } catch (Dali::DaliException e) {
5034       {
5035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5036       };
5037     } catch (...) {
5038       {
5039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5040       };
5041     }
5042   }
5043
5044   jresult = result;
5045   return jresult;
5046 }
5047
5048
5049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5050   unsigned int jresult ;
5051   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5052   Dali::Vector2 *arg2 = 0 ;
5053   bool result;
5054
5055   arg1 = (Dali::Vector2 *)jarg1;
5056   arg2 = (Dali::Vector2 *)jarg2;
5057   if (!arg2) {
5058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5059     return 0;
5060   }
5061   {
5062     try {
5063       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5064     } catch (std::out_of_range& e) {
5065       {
5066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5067       };
5068     } catch (std::exception& e) {
5069       {
5070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5071       };
5072     } catch (Dali::DaliException e) {
5073       {
5074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5075       };
5076     } catch (...) {
5077       {
5078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5079       };
5080     }
5081   }
5082
5083   jresult = result;
5084   return jresult;
5085 }
5086
5087
5088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5089   float jresult ;
5090   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5091   unsigned int arg2 ;
5092   float *result = 0 ;
5093
5094   arg1 = (Dali::Vector2 *)jarg1;
5095   arg2 = (unsigned int)jarg2;
5096   {
5097     try {
5098       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5099     } catch (std::out_of_range& e) {
5100       {
5101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5102       };
5103     } catch (std::exception& e) {
5104       {
5105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5106       };
5107     } catch (Dali::DaliException e) {
5108       {
5109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5110       };
5111     } catch (...) {
5112       {
5113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5114       };
5115     }
5116   }
5117
5118   jresult = *result;
5119   return jresult;
5120 }
5121
5122
5123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5124   float jresult ;
5125   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5126   float result;
5127
5128   arg1 = (Dali::Vector2 *)jarg1;
5129   {
5130     try {
5131       result = (float)((Dali::Vector2 const *)arg1)->Length();
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_LengthSquared(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)->LengthSquared();
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 void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5190   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5191
5192   arg1 = (Dali::Vector2 *)jarg1;
5193   {
5194     try {
5195       (arg1)->Normalize();
5196     } catch (std::out_of_range& e) {
5197       {
5198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5199       };
5200     } catch (std::exception& e) {
5201       {
5202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5203       };
5204     } catch (Dali::DaliException e) {
5205       {
5206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5207       };
5208     } catch (...) {
5209       {
5210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5211       };
5212     }
5213   }
5214
5215 }
5216
5217
5218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5219   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5220   Dali::Vector2 *arg2 = 0 ;
5221   Dali::Vector2 *arg3 = 0 ;
5222
5223   arg1 = (Dali::Vector2 *)jarg1;
5224   arg2 = (Dali::Vector2 *)jarg2;
5225   if (!arg2) {
5226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5227     return ;
5228   }
5229   arg3 = (Dali::Vector2 *)jarg3;
5230   if (!arg3) {
5231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5232     return ;
5233   }
5234   {
5235     try {
5236       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5237     } catch (std::out_of_range& e) {
5238       {
5239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5240       };
5241     } catch (std::exception& e) {
5242       {
5243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5244       };
5245     } catch (Dali::DaliException e) {
5246       {
5247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5248       };
5249     } catch (...) {
5250       {
5251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5252       };
5253     }
5254   }
5255
5256 }
5257
5258
5259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5260   void * jresult ;
5261   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5262   float *result = 0 ;
5263
5264   arg1 = (Dali::Vector2 *)jarg1;
5265   {
5266     try {
5267       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5268     } catch (std::out_of_range& e) {
5269       {
5270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5271       };
5272     } catch (std::exception& e) {
5273       {
5274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5275       };
5276     } catch (Dali::DaliException e) {
5277       {
5278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5279       };
5280     } catch (...) {
5281       {
5282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5283       };
5284     }
5285   }
5286
5287   jresult = (void *)result;
5288   return jresult;
5289 }
5290
5291
5292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5293   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5294   float arg2 ;
5295
5296   arg1 = (Dali::Vector2 *)jarg1;
5297   arg2 = (float)jarg2;
5298   if (arg1) (arg1)->x = arg2;
5299 }
5300
5301
5302 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5303   float jresult ;
5304   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5305   float result;
5306
5307   arg1 = (Dali::Vector2 *)jarg1;
5308   result = (float) ((arg1)->x);
5309   jresult = result;
5310   return jresult;
5311 }
5312
5313
5314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5315   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5316   float arg2 ;
5317
5318   arg1 = (Dali::Vector2 *)jarg1;
5319   arg2 = (float)jarg2;
5320   if (arg1) (arg1)->width = arg2;
5321 }
5322
5323
5324 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5325   float jresult ;
5326   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5327   float result;
5328
5329   arg1 = (Dali::Vector2 *)jarg1;
5330   result = (float) ((arg1)->width);
5331   jresult = result;
5332   return jresult;
5333 }
5334
5335
5336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5337   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5338   float arg2 ;
5339
5340   arg1 = (Dali::Vector2 *)jarg1;
5341   arg2 = (float)jarg2;
5342   if (arg1) (arg1)->y = arg2;
5343 }
5344
5345
5346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5347   float jresult ;
5348   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5349   float result;
5350
5351   arg1 = (Dali::Vector2 *)jarg1;
5352   result = (float) ((arg1)->y);
5353   jresult = result;
5354   return jresult;
5355 }
5356
5357
5358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5359   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5360   float arg2 ;
5361
5362   arg1 = (Dali::Vector2 *)jarg1;
5363   arg2 = (float)jarg2;
5364   if (arg1) (arg1)->height = arg2;
5365 }
5366
5367
5368 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5369   float jresult ;
5370   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5371   float result;
5372
5373   arg1 = (Dali::Vector2 *)jarg1;
5374   result = (float) ((arg1)->height);
5375   jresult = result;
5376   return jresult;
5377 }
5378
5379
5380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5381   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5382
5383   arg1 = (Dali::Vector2 *)jarg1;
5384   {
5385     try {
5386       delete arg1;
5387     } catch (std::out_of_range& e) {
5388       {
5389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5390       };
5391     } catch (std::exception& e) {
5392       {
5393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5394       };
5395     } catch (Dali::DaliException e) {
5396       {
5397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5398       };
5399     } catch (...) {
5400       {
5401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5402       };
5403     }
5404   }
5405
5406 }
5407
5408
5409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5410   void * jresult ;
5411   Dali::Vector2 *arg1 = 0 ;
5412   Dali::Vector2 *arg2 = 0 ;
5413   Dali::Vector2 result;
5414
5415   arg1 = (Dali::Vector2 *)jarg1;
5416   if (!arg1) {
5417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5418     return 0;
5419   }
5420   arg2 = (Dali::Vector2 *)jarg2;
5421   if (!arg2) {
5422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5423     return 0;
5424   }
5425   {
5426     try {
5427       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5428     } catch (std::out_of_range& e) {
5429       {
5430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5431       };
5432     } catch (std::exception& e) {
5433       {
5434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5435       };
5436     } catch (Dali::DaliException e) {
5437       {
5438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5439       };
5440     } catch (...) {
5441       {
5442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5443       };
5444     }
5445   }
5446
5447   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5448   return jresult;
5449 }
5450
5451
5452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5453   void * jresult ;
5454   Dali::Vector2 *arg1 = 0 ;
5455   Dali::Vector2 *arg2 = 0 ;
5456   Dali::Vector2 result;
5457
5458   arg1 = (Dali::Vector2 *)jarg1;
5459   if (!arg1) {
5460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5461     return 0;
5462   }
5463   arg2 = (Dali::Vector2 *)jarg2;
5464   if (!arg2) {
5465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5466     return 0;
5467   }
5468   {
5469     try {
5470       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5471     } catch (std::out_of_range& e) {
5472       {
5473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5474       };
5475     } catch (std::exception& e) {
5476       {
5477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5478       };
5479     } catch (Dali::DaliException e) {
5480       {
5481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5482       };
5483     } catch (...) {
5484       {
5485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5486       };
5487     }
5488   }
5489
5490   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5491   return jresult;
5492 }
5493
5494
5495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5496   void * jresult ;
5497   Dali::Vector2 *arg1 = 0 ;
5498   float *arg2 = 0 ;
5499   float *arg3 = 0 ;
5500   float temp2 ;
5501   float temp3 ;
5502   Dali::Vector2 result;
5503
5504   arg1 = (Dali::Vector2 *)jarg1;
5505   if (!arg1) {
5506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5507     return 0;
5508   }
5509   temp2 = (float)jarg2;
5510   arg2 = &temp2;
5511   temp3 = (float)jarg3;
5512   arg3 = &temp3;
5513   {
5514     try {
5515       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5516     } catch (std::out_of_range& e) {
5517       {
5518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5519       };
5520     } catch (std::exception& e) {
5521       {
5522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5523       };
5524     } catch (Dali::DaliException e) {
5525       {
5526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5527       };
5528     } catch (...) {
5529       {
5530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5531       };
5532     }
5533   }
5534
5535   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5536   return jresult;
5537 }
5538
5539
5540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5541   void * jresult ;
5542   Dali::Vector3 *result = 0 ;
5543
5544   {
5545     try {
5546       result = (Dali::Vector3 *)new Dali::Vector3();
5547     } catch (std::out_of_range& e) {
5548       {
5549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5550       };
5551     } catch (std::exception& e) {
5552       {
5553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5554       };
5555     } catch (Dali::DaliException e) {
5556       {
5557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5558       };
5559     } catch (...) {
5560       {
5561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5562       };
5563     }
5564   }
5565
5566   jresult = (void *)result;
5567   return jresult;
5568 }
5569
5570
5571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5572   void * jresult ;
5573   float arg1 ;
5574   float arg2 ;
5575   float arg3 ;
5576   Dali::Vector3 *result = 0 ;
5577
5578   arg1 = (float)jarg1;
5579   arg2 = (float)jarg2;
5580   arg3 = (float)jarg3;
5581   {
5582     try {
5583       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5584     } catch (std::out_of_range& e) {
5585       {
5586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5587       };
5588     } catch (std::exception& e) {
5589       {
5590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5591       };
5592     } catch (Dali::DaliException e) {
5593       {
5594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5595       };
5596     } catch (...) {
5597       {
5598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5599       };
5600     }
5601   }
5602
5603   jresult = (void *)result;
5604   return jresult;
5605 }
5606
5607
5608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5609   void * jresult ;
5610   float *arg1 = (float *) 0 ;
5611   Dali::Vector3 *result = 0 ;
5612
5613   arg1 = jarg1;
5614   {
5615     try {
5616       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
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
5638
5639   return jresult;
5640 }
5641
5642
5643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5644   void * jresult ;
5645   Dali::Vector2 *arg1 = 0 ;
5646   Dali::Vector3 *result = 0 ;
5647
5648   arg1 = (Dali::Vector2 *)jarg1;
5649   if (!arg1) {
5650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5651     return 0;
5652   }
5653   {
5654     try {
5655       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5656     } catch (std::out_of_range& e) {
5657       {
5658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5659       };
5660     } catch (std::exception& e) {
5661       {
5662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5663       };
5664     } catch (Dali::DaliException e) {
5665       {
5666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5667       };
5668     } catch (...) {
5669       {
5670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5671       };
5672     }
5673   }
5674
5675   jresult = (void *)result;
5676   return jresult;
5677 }
5678
5679
5680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5681   void * jresult ;
5682   Dali::Vector4 *arg1 = 0 ;
5683   Dali::Vector3 *result = 0 ;
5684
5685   arg1 = (Dali::Vector4 *)jarg1;
5686   if (!arg1) {
5687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5688     return 0;
5689   }
5690   {
5691     try {
5692       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5693     } catch (std::out_of_range& e) {
5694       {
5695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5696       };
5697     } catch (std::exception& e) {
5698       {
5699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5700       };
5701     } catch (Dali::DaliException e) {
5702       {
5703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5704       };
5705     } catch (...) {
5706       {
5707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5708       };
5709     }
5710   }
5711
5712   jresult = (void *)result;
5713   return jresult;
5714 }
5715
5716
5717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5718   void * jresult ;
5719   Dali::Vector3 *result = 0 ;
5720
5721   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5722   jresult = (void *)result;
5723   return jresult;
5724 }
5725
5726
5727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5728   void * jresult ;
5729   Dali::Vector3 *result = 0 ;
5730
5731   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5732   jresult = (void *)result;
5733   return jresult;
5734 }
5735
5736
5737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5738   void * jresult ;
5739   Dali::Vector3 *result = 0 ;
5740
5741   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5742   jresult = (void *)result;
5743   return jresult;
5744 }
5745
5746
5747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5748   void * jresult ;
5749   Dali::Vector3 *result = 0 ;
5750
5751   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5752   jresult = (void *)result;
5753   return jresult;
5754 }
5755
5756
5757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5758   void * jresult ;
5759   Dali::Vector3 *result = 0 ;
5760
5761   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5762   jresult = (void *)result;
5763   return jresult;
5764 }
5765
5766
5767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5768   void * jresult ;
5769   Dali::Vector3 *result = 0 ;
5770
5771   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5772   jresult = (void *)result;
5773   return jresult;
5774 }
5775
5776
5777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5778   void * jresult ;
5779   Dali::Vector3 *result = 0 ;
5780
5781   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5782   jresult = (void *)result;
5783   return jresult;
5784 }
5785
5786
5787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5788   void * jresult ;
5789   Dali::Vector3 *result = 0 ;
5790
5791   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5792   jresult = (void *)result;
5793   return jresult;
5794 }
5795
5796
5797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5798   void * jresult ;
5799   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5800   float *arg2 = (float *) 0 ;
5801   Dali::Vector3 *result = 0 ;
5802
5803   arg1 = (Dali::Vector3 *)jarg1;
5804   arg2 = jarg2;
5805   {
5806     try {
5807       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5808     } catch (std::out_of_range& e) {
5809       {
5810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5811       };
5812     } catch (std::exception& e) {
5813       {
5814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5815       };
5816     } catch (Dali::DaliException e) {
5817       {
5818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5819       };
5820     } catch (...) {
5821       {
5822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5823       };
5824     }
5825   }
5826
5827   jresult = (void *)result;
5828
5829
5830   return jresult;
5831 }
5832
5833
5834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5835   void * jresult ;
5836   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5837   Dali::Vector2 *arg2 = 0 ;
5838   Dali::Vector3 *result = 0 ;
5839
5840   arg1 = (Dali::Vector3 *)jarg1;
5841   arg2 = (Dali::Vector2 *)jarg2;
5842   if (!arg2) {
5843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5844     return 0;
5845   }
5846   {
5847     try {
5848       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5849     } catch (std::out_of_range& e) {
5850       {
5851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5852       };
5853     } catch (std::exception& e) {
5854       {
5855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5856       };
5857     } catch (Dali::DaliException e) {
5858       {
5859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5860       };
5861     } catch (...) {
5862       {
5863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5864       };
5865     }
5866   }
5867
5868   jresult = (void *)result;
5869   return jresult;
5870 }
5871
5872
5873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5874   void * jresult ;
5875   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5876   Dali::Vector4 *arg2 = 0 ;
5877   Dali::Vector3 *result = 0 ;
5878
5879   arg1 = (Dali::Vector3 *)jarg1;
5880   arg2 = (Dali::Vector4 *)jarg2;
5881   if (!arg2) {
5882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5883     return 0;
5884   }
5885   {
5886     try {
5887       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5888     } catch (std::out_of_range& e) {
5889       {
5890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5891       };
5892     } catch (std::exception& e) {
5893       {
5894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5895       };
5896     } catch (Dali::DaliException e) {
5897       {
5898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5899       };
5900     } catch (...) {
5901       {
5902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5903       };
5904     }
5905   }
5906
5907   jresult = (void *)result;
5908   return jresult;
5909 }
5910
5911
5912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5913   void * jresult ;
5914   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5915   Dali::Vector3 *arg2 = 0 ;
5916   Dali::Vector3 result;
5917
5918   arg1 = (Dali::Vector3 *)jarg1;
5919   arg2 = (Dali::Vector3 *)jarg2;
5920   if (!arg2) {
5921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5922     return 0;
5923   }
5924   {
5925     try {
5926       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5927     } catch (std::out_of_range& e) {
5928       {
5929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5930       };
5931     } catch (std::exception& e) {
5932       {
5933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5934       };
5935     } catch (Dali::DaliException e) {
5936       {
5937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5938       };
5939     } catch (...) {
5940       {
5941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5942       };
5943     }
5944   }
5945
5946   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5947   return jresult;
5948 }
5949
5950
5951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5952   void * jresult ;
5953   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5954   Dali::Vector3 *arg2 = 0 ;
5955   Dali::Vector3 *result = 0 ;
5956
5957   arg1 = (Dali::Vector3 *)jarg1;
5958   arg2 = (Dali::Vector3 *)jarg2;
5959   if (!arg2) {
5960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5961     return 0;
5962   }
5963   {
5964     try {
5965       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5966     } catch (std::out_of_range& e) {
5967       {
5968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5969       };
5970     } catch (std::exception& e) {
5971       {
5972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5973       };
5974     } catch (Dali::DaliException e) {
5975       {
5976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5977       };
5978     } catch (...) {
5979       {
5980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5981       };
5982     }
5983   }
5984
5985   jresult = (void *)result;
5986   return jresult;
5987 }
5988
5989
5990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5991   void * jresult ;
5992   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5993   Dali::Vector3 *arg2 = 0 ;
5994   Dali::Vector3 result;
5995
5996   arg1 = (Dali::Vector3 *)jarg1;
5997   arg2 = (Dali::Vector3 *)jarg2;
5998   if (!arg2) {
5999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6000     return 0;
6001   }
6002   {
6003     try {
6004       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6005     } catch (std::out_of_range& e) {
6006       {
6007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6008       };
6009     } catch (std::exception& e) {
6010       {
6011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6012       };
6013     } catch (Dali::DaliException e) {
6014       {
6015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6016       };
6017     } catch (...) {
6018       {
6019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6020       };
6021     }
6022   }
6023
6024   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6025   return jresult;
6026 }
6027
6028
6029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6030   void * jresult ;
6031   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6032   Dali::Vector3 *arg2 = 0 ;
6033   Dali::Vector3 *result = 0 ;
6034
6035   arg1 = (Dali::Vector3 *)jarg1;
6036   arg2 = (Dali::Vector3 *)jarg2;
6037   if (!arg2) {
6038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6039     return 0;
6040   }
6041   {
6042     try {
6043       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6044     } catch (std::out_of_range& e) {
6045       {
6046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6047       };
6048     } catch (std::exception& e) {
6049       {
6050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6051       };
6052     } catch (Dali::DaliException e) {
6053       {
6054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6055       };
6056     } catch (...) {
6057       {
6058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6059       };
6060     }
6061   }
6062
6063   jresult = (void *)result;
6064   return jresult;
6065 }
6066
6067
6068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6069   void * jresult ;
6070   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6071   Dali::Vector3 *arg2 = 0 ;
6072   Dali::Vector3 result;
6073
6074   arg1 = (Dali::Vector3 *)jarg1;
6075   arg2 = (Dali::Vector3 *)jarg2;
6076   if (!arg2) {
6077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6078     return 0;
6079   }
6080   {
6081     try {
6082       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6083     } catch (std::out_of_range& e) {
6084       {
6085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6086       };
6087     } catch (std::exception& e) {
6088       {
6089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6090       };
6091     } catch (Dali::DaliException e) {
6092       {
6093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6094       };
6095     } catch (...) {
6096       {
6097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6098       };
6099     }
6100   }
6101
6102   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6103   return jresult;
6104 }
6105
6106
6107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6108   void * jresult ;
6109   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6110   float arg2 ;
6111   Dali::Vector3 result;
6112
6113   arg1 = (Dali::Vector3 *)jarg1;
6114   arg2 = (float)jarg2;
6115   {
6116     try {
6117       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6118     } catch (std::out_of_range& e) {
6119       {
6120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6121       };
6122     } catch (std::exception& e) {
6123       {
6124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6125       };
6126     } catch (Dali::DaliException e) {
6127       {
6128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6129       };
6130     } catch (...) {
6131       {
6132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6133       };
6134     }
6135   }
6136
6137   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6138   return jresult;
6139 }
6140
6141
6142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6143   void * jresult ;
6144   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6145   Dali::Vector3 *arg2 = 0 ;
6146   Dali::Vector3 *result = 0 ;
6147
6148   arg1 = (Dali::Vector3 *)jarg1;
6149   arg2 = (Dali::Vector3 *)jarg2;
6150   if (!arg2) {
6151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6152     return 0;
6153   }
6154   {
6155     try {
6156       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6157     } catch (std::out_of_range& e) {
6158       {
6159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6160       };
6161     } catch (std::exception& e) {
6162       {
6163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6164       };
6165     } catch (Dali::DaliException e) {
6166       {
6167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6168       };
6169     } catch (...) {
6170       {
6171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6172       };
6173     }
6174   }
6175
6176   jresult = (void *)result;
6177   return jresult;
6178 }
6179
6180
6181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6182   void * jresult ;
6183   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6184   float arg2 ;
6185   Dali::Vector3 *result = 0 ;
6186
6187   arg1 = (Dali::Vector3 *)jarg1;
6188   arg2 = (float)jarg2;
6189   {
6190     try {
6191       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6192     } catch (std::out_of_range& e) {
6193       {
6194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6195       };
6196     } catch (std::exception& e) {
6197       {
6198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6199       };
6200     } catch (Dali::DaliException e) {
6201       {
6202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6203       };
6204     } catch (...) {
6205       {
6206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6207       };
6208     }
6209   }
6210
6211   jresult = (void *)result;
6212   return jresult;
6213 }
6214
6215
6216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6217   void * jresult ;
6218   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6219   Dali::Quaternion *arg2 = 0 ;
6220   Dali::Vector3 *result = 0 ;
6221
6222   arg1 = (Dali::Vector3 *)jarg1;
6223   arg2 = (Dali::Quaternion *)jarg2;
6224   if (!arg2) {
6225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6226     return 0;
6227   }
6228   {
6229     try {
6230       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6231     } catch (std::out_of_range& e) {
6232       {
6233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6234       };
6235     } catch (std::exception& e) {
6236       {
6237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6238       };
6239     } catch (Dali::DaliException e) {
6240       {
6241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6242       };
6243     } catch (...) {
6244       {
6245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6246       };
6247     }
6248   }
6249
6250   jresult = (void *)result;
6251   return jresult;
6252 }
6253
6254
6255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6256   void * jresult ;
6257   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6258   Dali::Vector3 *arg2 = 0 ;
6259   Dali::Vector3 result;
6260
6261   arg1 = (Dali::Vector3 *)jarg1;
6262   arg2 = (Dali::Vector3 *)jarg2;
6263   if (!arg2) {
6264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6265     return 0;
6266   }
6267   {
6268     try {
6269       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6270     } catch (std::out_of_range& e) {
6271       {
6272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6273       };
6274     } catch (std::exception& e) {
6275       {
6276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6277       };
6278     } catch (Dali::DaliException e) {
6279       {
6280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6281       };
6282     } catch (...) {
6283       {
6284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6285       };
6286     }
6287   }
6288
6289   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6290   return jresult;
6291 }
6292
6293
6294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6295   void * jresult ;
6296   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6297   float arg2 ;
6298   Dali::Vector3 result;
6299
6300   arg1 = (Dali::Vector3 *)jarg1;
6301   arg2 = (float)jarg2;
6302   {
6303     try {
6304       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6305     } catch (std::out_of_range& e) {
6306       {
6307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6308       };
6309     } catch (std::exception& e) {
6310       {
6311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6312       };
6313     } catch (Dali::DaliException e) {
6314       {
6315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6316       };
6317     } catch (...) {
6318       {
6319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6320       };
6321     }
6322   }
6323
6324   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6325   return jresult;
6326 }
6327
6328
6329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6330   void * jresult ;
6331   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6332   Dali::Vector3 *arg2 = 0 ;
6333   Dali::Vector3 *result = 0 ;
6334
6335   arg1 = (Dali::Vector3 *)jarg1;
6336   arg2 = (Dali::Vector3 *)jarg2;
6337   if (!arg2) {
6338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6339     return 0;
6340   }
6341   {
6342     try {
6343       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6344     } catch (std::out_of_range& e) {
6345       {
6346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6347       };
6348     } catch (std::exception& e) {
6349       {
6350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6351       };
6352     } catch (Dali::DaliException e) {
6353       {
6354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6355       };
6356     } catch (...) {
6357       {
6358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6359       };
6360     }
6361   }
6362
6363   jresult = (void *)result;
6364   return jresult;
6365 }
6366
6367
6368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6369   void * jresult ;
6370   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6371   float arg2 ;
6372   Dali::Vector3 *result = 0 ;
6373
6374   arg1 = (Dali::Vector3 *)jarg1;
6375   arg2 = (float)jarg2;
6376   {
6377     try {
6378       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6379     } catch (std::out_of_range& e) {
6380       {
6381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6382       };
6383     } catch (std::exception& e) {
6384       {
6385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6386       };
6387     } catch (Dali::DaliException e) {
6388       {
6389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6390       };
6391     } catch (...) {
6392       {
6393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6394       };
6395     }
6396   }
6397
6398   jresult = (void *)result;
6399   return jresult;
6400 }
6401
6402
6403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6404   void * jresult ;
6405   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6406   Dali::Vector3 result;
6407
6408   arg1 = (Dali::Vector3 *)jarg1;
6409   {
6410     try {
6411       result = ((Dali::Vector3 const *)arg1)->operator -();
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 = new Dali::Vector3((const Dali::Vector3 &)result);
6432   return jresult;
6433 }
6434
6435
6436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6437   unsigned int jresult ;
6438   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6439   Dali::Vector3 *arg2 = 0 ;
6440   bool result;
6441
6442   arg1 = (Dali::Vector3 *)jarg1;
6443   arg2 = (Dali::Vector3 *)jarg2;
6444   if (!arg2) {
6445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6446     return 0;
6447   }
6448   {
6449     try {
6450       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6451     } catch (std::out_of_range& e) {
6452       {
6453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6454       };
6455     } catch (std::exception& e) {
6456       {
6457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6458       };
6459     } catch (Dali::DaliException e) {
6460       {
6461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6462       };
6463     } catch (...) {
6464       {
6465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6466       };
6467     }
6468   }
6469
6470   jresult = result;
6471   return jresult;
6472 }
6473
6474
6475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6476   unsigned int jresult ;
6477   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6478   Dali::Vector3 *arg2 = 0 ;
6479   bool result;
6480
6481   arg1 = (Dali::Vector3 *)jarg1;
6482   arg2 = (Dali::Vector3 *)jarg2;
6483   if (!arg2) {
6484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6485     return 0;
6486   }
6487   {
6488     try {
6489       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6490     } catch (std::out_of_range& e) {
6491       {
6492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6493       };
6494     } catch (std::exception& e) {
6495       {
6496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6497       };
6498     } catch (Dali::DaliException e) {
6499       {
6500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6501       };
6502     } catch (...) {
6503       {
6504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6505       };
6506     }
6507   }
6508
6509   jresult = result;
6510   return jresult;
6511 }
6512
6513
6514 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6515   float jresult ;
6516   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6517   unsigned int arg2 ;
6518   float *result = 0 ;
6519
6520   arg1 = (Dali::Vector3 *)jarg1;
6521   arg2 = (unsigned int)jarg2;
6522   {
6523     try {
6524       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6525     } catch (std::out_of_range& e) {
6526       {
6527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6528       };
6529     } catch (std::exception& e) {
6530       {
6531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6532       };
6533     } catch (Dali::DaliException e) {
6534       {
6535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6536       };
6537     } catch (...) {
6538       {
6539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6540       };
6541     }
6542   }
6543
6544   jresult = *result;
6545   return jresult;
6546 }
6547
6548
6549 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6550   float jresult ;
6551   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6552   Dali::Vector3 *arg2 = 0 ;
6553   float result;
6554
6555   arg1 = (Dali::Vector3 *)jarg1;
6556   arg2 = (Dali::Vector3 *)jarg2;
6557   if (!arg2) {
6558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6559     return 0;
6560   }
6561   {
6562     try {
6563       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6564     } catch (std::out_of_range& e) {
6565       {
6566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6567       };
6568     } catch (std::exception& e) {
6569       {
6570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6571       };
6572     } catch (Dali::DaliException e) {
6573       {
6574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6575       };
6576     } catch (...) {
6577       {
6578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6579       };
6580     }
6581   }
6582
6583   jresult = result;
6584   return jresult;
6585 }
6586
6587
6588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6589   void * jresult ;
6590   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6591   Dali::Vector3 *arg2 = 0 ;
6592   Dali::Vector3 result;
6593
6594   arg1 = (Dali::Vector3 *)jarg1;
6595   arg2 = (Dali::Vector3 *)jarg2;
6596   if (!arg2) {
6597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6598     return 0;
6599   }
6600   {
6601     try {
6602       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6603     } catch (std::out_of_range& e) {
6604       {
6605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6606       };
6607     } catch (std::exception& e) {
6608       {
6609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6610       };
6611     } catch (Dali::DaliException e) {
6612       {
6613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6614       };
6615     } catch (...) {
6616       {
6617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6618       };
6619     }
6620   }
6621
6622   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6623   return jresult;
6624 }
6625
6626
6627 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6628   float jresult ;
6629   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6630   float result;
6631
6632   arg1 = (Dali::Vector3 *)jarg1;
6633   {
6634     try {
6635       result = (float)((Dali::Vector3 const *)arg1)->Length();
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 = result;
6656   return jresult;
6657 }
6658
6659
6660 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(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)->LengthSquared();
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 void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6694   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6695
6696   arg1 = (Dali::Vector3 *)jarg1;
6697   {
6698     try {
6699       (arg1)->Normalize();
6700     } catch (std::out_of_range& e) {
6701       {
6702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6703       };
6704     } catch (std::exception& e) {
6705       {
6706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6707       };
6708     } catch (Dali::DaliException e) {
6709       {
6710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6711       };
6712     } catch (...) {
6713       {
6714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6715       };
6716     }
6717   }
6718
6719 }
6720
6721
6722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6723   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6724   Dali::Vector3 *arg2 = 0 ;
6725   Dali::Vector3 *arg3 = 0 ;
6726
6727   arg1 = (Dali::Vector3 *)jarg1;
6728   arg2 = (Dali::Vector3 *)jarg2;
6729   if (!arg2) {
6730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6731     return ;
6732   }
6733   arg3 = (Dali::Vector3 *)jarg3;
6734   if (!arg3) {
6735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6736     return ;
6737   }
6738   {
6739     try {
6740       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6741     } catch (std::out_of_range& e) {
6742       {
6743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6744       };
6745     } catch (std::exception& e) {
6746       {
6747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6748       };
6749     } catch (Dali::DaliException e) {
6750       {
6751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6752       };
6753     } catch (...) {
6754       {
6755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6756       };
6757     }
6758   }
6759
6760 }
6761
6762
6763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6764   void * jresult ;
6765   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6766   float *result = 0 ;
6767
6768   arg1 = (Dali::Vector3 *)jarg1;
6769   {
6770     try {
6771       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6772     } catch (std::out_of_range& e) {
6773       {
6774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6775       };
6776     } catch (std::exception& e) {
6777       {
6778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6779       };
6780     } catch (Dali::DaliException e) {
6781       {
6782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6783       };
6784     } catch (...) {
6785       {
6786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6787       };
6788     }
6789   }
6790
6791   jresult = (void *)result;
6792   return jresult;
6793 }
6794
6795
6796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6797   void * jresult ;
6798   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6799   Dali::Vector2 *result = 0 ;
6800
6801   arg1 = (Dali::Vector3 *)jarg1;
6802   {
6803     try {
6804       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
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_GetVectorYZ__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)->GetVectorYZ();
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_X_set(void * jarg1, float jarg2) {
6863   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6864   float arg2 ;
6865
6866   arg1 = (Dali::Vector3 *)jarg1;
6867   arg2 = (float)jarg2;
6868   if (arg1) (arg1)->x = arg2;
6869 }
6870
6871
6872 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6873   float jresult ;
6874   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6875   float result;
6876
6877   arg1 = (Dali::Vector3 *)jarg1;
6878   result = (float) ((arg1)->x);
6879   jresult = result;
6880   return jresult;
6881 }
6882
6883
6884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6885   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6886   float arg2 ;
6887
6888   arg1 = (Dali::Vector3 *)jarg1;
6889   arg2 = (float)jarg2;
6890   if (arg1) (arg1)->width = arg2;
6891 }
6892
6893
6894 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6895   float jresult ;
6896   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6897   float result;
6898
6899   arg1 = (Dali::Vector3 *)jarg1;
6900   result = (float) ((arg1)->width);
6901   jresult = result;
6902   return jresult;
6903 }
6904
6905
6906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6907   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6908   float arg2 ;
6909
6910   arg1 = (Dali::Vector3 *)jarg1;
6911   arg2 = (float)jarg2;
6912   if (arg1) (arg1)->r = arg2;
6913 }
6914
6915
6916 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6917   float jresult ;
6918   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6919   float result;
6920
6921   arg1 = (Dali::Vector3 *)jarg1;
6922   result = (float) ((arg1)->r);
6923   jresult = result;
6924   return jresult;
6925 }
6926
6927
6928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6929   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6930   float arg2 ;
6931
6932   arg1 = (Dali::Vector3 *)jarg1;
6933   arg2 = (float)jarg2;
6934   if (arg1) (arg1)->y = arg2;
6935 }
6936
6937
6938 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6939   float jresult ;
6940   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6941   float result;
6942
6943   arg1 = (Dali::Vector3 *)jarg1;
6944   result = (float) ((arg1)->y);
6945   jresult = result;
6946   return jresult;
6947 }
6948
6949
6950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6951   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6952   float arg2 ;
6953
6954   arg1 = (Dali::Vector3 *)jarg1;
6955   arg2 = (float)jarg2;
6956   if (arg1) (arg1)->height = arg2;
6957 }
6958
6959
6960 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6961   float jresult ;
6962   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6963   float result;
6964
6965   arg1 = (Dali::Vector3 *)jarg1;
6966   result = (float) ((arg1)->height);
6967   jresult = result;
6968   return jresult;
6969 }
6970
6971
6972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6973   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6974   float arg2 ;
6975
6976   arg1 = (Dali::Vector3 *)jarg1;
6977   arg2 = (float)jarg2;
6978   if (arg1) (arg1)->g = arg2;
6979 }
6980
6981
6982 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6983   float jresult ;
6984   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6985   float result;
6986
6987   arg1 = (Dali::Vector3 *)jarg1;
6988   result = (float) ((arg1)->g);
6989   jresult = result;
6990   return jresult;
6991 }
6992
6993
6994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6995   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6996   float arg2 ;
6997
6998   arg1 = (Dali::Vector3 *)jarg1;
6999   arg2 = (float)jarg2;
7000   if (arg1) (arg1)->z = arg2;
7001 }
7002
7003
7004 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7005   float jresult ;
7006   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7007   float result;
7008
7009   arg1 = (Dali::Vector3 *)jarg1;
7010   result = (float) ((arg1)->z);
7011   jresult = result;
7012   return jresult;
7013 }
7014
7015
7016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7017   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7018   float arg2 ;
7019
7020   arg1 = (Dali::Vector3 *)jarg1;
7021   arg2 = (float)jarg2;
7022   if (arg1) (arg1)->depth = arg2;
7023 }
7024
7025
7026 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7027   float jresult ;
7028   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7029   float result;
7030
7031   arg1 = (Dali::Vector3 *)jarg1;
7032   result = (float) ((arg1)->depth);
7033   jresult = result;
7034   return jresult;
7035 }
7036
7037
7038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7039   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7040   float arg2 ;
7041
7042   arg1 = (Dali::Vector3 *)jarg1;
7043   arg2 = (float)jarg2;
7044   if (arg1) (arg1)->b = arg2;
7045 }
7046
7047
7048 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7049   float jresult ;
7050   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7051   float result;
7052
7053   arg1 = (Dali::Vector3 *)jarg1;
7054   result = (float) ((arg1)->b);
7055   jresult = result;
7056   return jresult;
7057 }
7058
7059
7060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7061   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7062
7063   arg1 = (Dali::Vector3 *)jarg1;
7064   {
7065     try {
7066       delete arg1;
7067     } catch (std::out_of_range& e) {
7068       {
7069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7070       };
7071     } catch (std::exception& e) {
7072       {
7073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7074       };
7075     } catch (Dali::DaliException e) {
7076       {
7077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7078       };
7079     } catch (...) {
7080       {
7081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7082       };
7083     }
7084   }
7085
7086 }
7087
7088
7089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7090   void * jresult ;
7091   Dali::Vector3 *arg1 = 0 ;
7092   Dali::Vector3 *arg2 = 0 ;
7093   Dali::Vector3 result;
7094
7095   arg1 = (Dali::Vector3 *)jarg1;
7096   if (!arg1) {
7097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7098     return 0;
7099   }
7100   arg2 = (Dali::Vector3 *)jarg2;
7101   if (!arg2) {
7102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7103     return 0;
7104   }
7105   {
7106     try {
7107       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7108     } catch (std::out_of_range& e) {
7109       {
7110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7111       };
7112     } catch (std::exception& e) {
7113       {
7114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7115       };
7116     } catch (Dali::DaliException e) {
7117       {
7118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7119       };
7120     } catch (...) {
7121       {
7122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7123       };
7124     }
7125   }
7126
7127   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7128   return jresult;
7129 }
7130
7131
7132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7133   void * jresult ;
7134   Dali::Vector3 *arg1 = 0 ;
7135   Dali::Vector3 *arg2 = 0 ;
7136   Dali::Vector3 result;
7137
7138   arg1 = (Dali::Vector3 *)jarg1;
7139   if (!arg1) {
7140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7141     return 0;
7142   }
7143   arg2 = (Dali::Vector3 *)jarg2;
7144   if (!arg2) {
7145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7146     return 0;
7147   }
7148   {
7149     try {
7150       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7151     } catch (std::out_of_range& e) {
7152       {
7153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7154       };
7155     } catch (std::exception& e) {
7156       {
7157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7158       };
7159     } catch (Dali::DaliException e) {
7160       {
7161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7162       };
7163     } catch (...) {
7164       {
7165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7166       };
7167     }
7168   }
7169
7170   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7171   return jresult;
7172 }
7173
7174
7175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7176   void * jresult ;
7177   Dali::Vector3 *arg1 = 0 ;
7178   float *arg2 = 0 ;
7179   float *arg3 = 0 ;
7180   float temp2 ;
7181   float temp3 ;
7182   Dali::Vector3 result;
7183
7184   arg1 = (Dali::Vector3 *)jarg1;
7185   if (!arg1) {
7186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7187     return 0;
7188   }
7189   temp2 = (float)jarg2;
7190   arg2 = &temp2;
7191   temp3 = (float)jarg3;
7192   arg3 = &temp3;
7193   {
7194     try {
7195       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7196     } catch (std::out_of_range& e) {
7197       {
7198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7199       };
7200     } catch (std::exception& e) {
7201       {
7202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7203       };
7204     } catch (Dali::DaliException e) {
7205       {
7206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7207       };
7208     } catch (...) {
7209       {
7210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7211       };
7212     }
7213   }
7214
7215   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7216   return jresult;
7217 }
7218
7219
7220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7221   void * jresult ;
7222   Dali::Vector4 *result = 0 ;
7223
7224   {
7225     try {
7226       result = (Dali::Vector4 *)new Dali::Vector4();
7227     } catch (std::out_of_range& e) {
7228       {
7229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7230       };
7231     } catch (std::exception& e) {
7232       {
7233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7234       };
7235     } catch (Dali::DaliException e) {
7236       {
7237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7238       };
7239     } catch (...) {
7240       {
7241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7242       };
7243     }
7244   }
7245
7246   jresult = (void *)result;
7247   return jresult;
7248 }
7249
7250
7251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7252   void * jresult ;
7253   float arg1 ;
7254   float arg2 ;
7255   float arg3 ;
7256   float arg4 ;
7257   Dali::Vector4 *result = 0 ;
7258
7259   arg1 = (float)jarg1;
7260   arg2 = (float)jarg2;
7261   arg3 = (float)jarg3;
7262   arg4 = (float)jarg4;
7263   {
7264     try {
7265       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7266     } catch (std::out_of_range& e) {
7267       {
7268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7269       };
7270     } catch (std::exception& e) {
7271       {
7272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7273       };
7274     } catch (Dali::DaliException e) {
7275       {
7276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7277       };
7278     } catch (...) {
7279       {
7280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7281       };
7282     }
7283   }
7284
7285   jresult = (void *)result;
7286   return jresult;
7287 }
7288
7289
7290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7291   void * jresult ;
7292   float *arg1 = (float *) 0 ;
7293   Dali::Vector4 *result = 0 ;
7294
7295   arg1 = jarg1;
7296   {
7297     try {
7298       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
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
7320
7321   return jresult;
7322 }
7323
7324
7325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7326   void * jresult ;
7327   Dali::Vector2 *arg1 = 0 ;
7328   Dali::Vector4 *result = 0 ;
7329
7330   arg1 = (Dali::Vector2 *)jarg1;
7331   if (!arg1) {
7332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7333     return 0;
7334   }
7335   {
7336     try {
7337       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7338     } catch (std::out_of_range& e) {
7339       {
7340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7341       };
7342     } catch (std::exception& e) {
7343       {
7344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7345       };
7346     } catch (Dali::DaliException e) {
7347       {
7348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7349       };
7350     } catch (...) {
7351       {
7352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7353       };
7354     }
7355   }
7356
7357   jresult = (void *)result;
7358   return jresult;
7359 }
7360
7361
7362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7363   void * jresult ;
7364   Dali::Vector3 *arg1 = 0 ;
7365   Dali::Vector4 *result = 0 ;
7366
7367   arg1 = (Dali::Vector3 *)jarg1;
7368   if (!arg1) {
7369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7370     return 0;
7371   }
7372   {
7373     try {
7374       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7375     } catch (std::out_of_range& e) {
7376       {
7377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7378       };
7379     } catch (std::exception& e) {
7380       {
7381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7382       };
7383     } catch (Dali::DaliException e) {
7384       {
7385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7386       };
7387     } catch (...) {
7388       {
7389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7390       };
7391     }
7392   }
7393
7394   jresult = (void *)result;
7395   return jresult;
7396 }
7397
7398
7399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7400   void * jresult ;
7401   Dali::Vector4 *result = 0 ;
7402
7403   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7404   jresult = (void *)result;
7405   return jresult;
7406 }
7407
7408
7409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7410   void * jresult ;
7411   Dali::Vector4 *result = 0 ;
7412
7413   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7414   jresult = (void *)result;
7415   return jresult;
7416 }
7417
7418
7419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7420   void * jresult ;
7421   Dali::Vector4 *result = 0 ;
7422
7423   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7424   jresult = (void *)result;
7425   return jresult;
7426 }
7427
7428
7429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7430   void * jresult ;
7431   Dali::Vector4 *result = 0 ;
7432
7433   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7434   jresult = (void *)result;
7435   return jresult;
7436 }
7437
7438
7439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7440   void * jresult ;
7441   Dali::Vector4 *result = 0 ;
7442
7443   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7444   jresult = (void *)result;
7445   return jresult;
7446 }
7447
7448
7449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7450   void * jresult ;
7451   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7452   float *arg2 = (float *) 0 ;
7453   Dali::Vector4 *result = 0 ;
7454
7455   arg1 = (Dali::Vector4 *)jarg1;
7456   arg2 = jarg2;
7457   {
7458     try {
7459       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7460     } catch (std::out_of_range& e) {
7461       {
7462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7463       };
7464     } catch (std::exception& e) {
7465       {
7466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7467       };
7468     } catch (Dali::DaliException e) {
7469       {
7470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7471       };
7472     } catch (...) {
7473       {
7474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7475       };
7476     }
7477   }
7478
7479   jresult = (void *)result;
7480
7481
7482   return jresult;
7483 }
7484
7485
7486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7487   void * jresult ;
7488   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7489   Dali::Vector2 *arg2 = 0 ;
7490   Dali::Vector4 *result = 0 ;
7491
7492   arg1 = (Dali::Vector4 *)jarg1;
7493   arg2 = (Dali::Vector2 *)jarg2;
7494   if (!arg2) {
7495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7496     return 0;
7497   }
7498   {
7499     try {
7500       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7501     } catch (std::out_of_range& e) {
7502       {
7503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7504       };
7505     } catch (std::exception& e) {
7506       {
7507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7508       };
7509     } catch (Dali::DaliException e) {
7510       {
7511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7512       };
7513     } catch (...) {
7514       {
7515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7516       };
7517     }
7518   }
7519
7520   jresult = (void *)result;
7521   return jresult;
7522 }
7523
7524
7525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7526   void * jresult ;
7527   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7528   Dali::Vector3 *arg2 = 0 ;
7529   Dali::Vector4 *result = 0 ;
7530
7531   arg1 = (Dali::Vector4 *)jarg1;
7532   arg2 = (Dali::Vector3 *)jarg2;
7533   if (!arg2) {
7534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7535     return 0;
7536   }
7537   {
7538     try {
7539       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7540     } catch (std::out_of_range& e) {
7541       {
7542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7543       };
7544     } catch (std::exception& e) {
7545       {
7546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7547       };
7548     } catch (Dali::DaliException e) {
7549       {
7550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7551       };
7552     } catch (...) {
7553       {
7554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7555       };
7556     }
7557   }
7558
7559   jresult = (void *)result;
7560   return jresult;
7561 }
7562
7563
7564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7565   void * jresult ;
7566   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7567   Dali::Vector4 *arg2 = 0 ;
7568   Dali::Vector4 result;
7569
7570   arg1 = (Dali::Vector4 *)jarg1;
7571   arg2 = (Dali::Vector4 *)jarg2;
7572   if (!arg2) {
7573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7574     return 0;
7575   }
7576   {
7577     try {
7578       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7579     } catch (std::out_of_range& e) {
7580       {
7581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7582       };
7583     } catch (std::exception& e) {
7584       {
7585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7586       };
7587     } catch (Dali::DaliException e) {
7588       {
7589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7590       };
7591     } catch (...) {
7592       {
7593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7594       };
7595     }
7596   }
7597
7598   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7599   return jresult;
7600 }
7601
7602
7603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7604   void * jresult ;
7605   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7606   Dali::Vector4 *arg2 = 0 ;
7607   Dali::Vector4 *result = 0 ;
7608
7609   arg1 = (Dali::Vector4 *)jarg1;
7610   arg2 = (Dali::Vector4 *)jarg2;
7611   if (!arg2) {
7612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7613     return 0;
7614   }
7615   {
7616     try {
7617       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7618     } catch (std::out_of_range& e) {
7619       {
7620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7621       };
7622     } catch (std::exception& e) {
7623       {
7624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7625       };
7626     } catch (Dali::DaliException e) {
7627       {
7628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7629       };
7630     } catch (...) {
7631       {
7632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7633       };
7634     }
7635   }
7636
7637   jresult = (void *)result;
7638   return jresult;
7639 }
7640
7641
7642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7643   void * jresult ;
7644   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7645   Dali::Vector4 *arg2 = 0 ;
7646   Dali::Vector4 result;
7647
7648   arg1 = (Dali::Vector4 *)jarg1;
7649   arg2 = (Dali::Vector4 *)jarg2;
7650   if (!arg2) {
7651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7652     return 0;
7653   }
7654   {
7655     try {
7656       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7657     } catch (std::out_of_range& e) {
7658       {
7659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7660       };
7661     } catch (std::exception& e) {
7662       {
7663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7664       };
7665     } catch (Dali::DaliException e) {
7666       {
7667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7668       };
7669     } catch (...) {
7670       {
7671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7672       };
7673     }
7674   }
7675
7676   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7677   return jresult;
7678 }
7679
7680
7681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7682   void * jresult ;
7683   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7684   Dali::Vector4 *arg2 = 0 ;
7685   Dali::Vector4 *result = 0 ;
7686
7687   arg1 = (Dali::Vector4 *)jarg1;
7688   arg2 = (Dali::Vector4 *)jarg2;
7689   if (!arg2) {
7690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7691     return 0;
7692   }
7693   {
7694     try {
7695       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7696     } catch (std::out_of_range& e) {
7697       {
7698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7699       };
7700     } catch (std::exception& e) {
7701       {
7702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7703       };
7704     } catch (Dali::DaliException e) {
7705       {
7706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7707       };
7708     } catch (...) {
7709       {
7710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7711       };
7712     }
7713   }
7714
7715   jresult = (void *)result;
7716   return jresult;
7717 }
7718
7719
7720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7721   void * jresult ;
7722   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7723   Dali::Vector4 *arg2 = 0 ;
7724   Dali::Vector4 result;
7725
7726   arg1 = (Dali::Vector4 *)jarg1;
7727   arg2 = (Dali::Vector4 *)jarg2;
7728   if (!arg2) {
7729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7730     return 0;
7731   }
7732   {
7733     try {
7734       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7735     } catch (std::out_of_range& e) {
7736       {
7737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7738       };
7739     } catch (std::exception& e) {
7740       {
7741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7742       };
7743     } catch (Dali::DaliException e) {
7744       {
7745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7746       };
7747     } catch (...) {
7748       {
7749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7750       };
7751     }
7752   }
7753
7754   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7755   return jresult;
7756 }
7757
7758
7759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7760   void * jresult ;
7761   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7762   float arg2 ;
7763   Dali::Vector4 result;
7764
7765   arg1 = (Dali::Vector4 *)jarg1;
7766   arg2 = (float)jarg2;
7767   {
7768     try {
7769       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7770     } catch (std::out_of_range& e) {
7771       {
7772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7773       };
7774     } catch (std::exception& e) {
7775       {
7776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7777       };
7778     } catch (Dali::DaliException e) {
7779       {
7780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7781       };
7782     } catch (...) {
7783       {
7784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7785       };
7786     }
7787   }
7788
7789   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7790   return jresult;
7791 }
7792
7793
7794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7795   void * jresult ;
7796   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7797   Dali::Vector4 *arg2 = 0 ;
7798   Dali::Vector4 *result = 0 ;
7799
7800   arg1 = (Dali::Vector4 *)jarg1;
7801   arg2 = (Dali::Vector4 *)jarg2;
7802   if (!arg2) {
7803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7804     return 0;
7805   }
7806   {
7807     try {
7808       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7809     } catch (std::out_of_range& e) {
7810       {
7811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7812       };
7813     } catch (std::exception& e) {
7814       {
7815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7816       };
7817     } catch (Dali::DaliException e) {
7818       {
7819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7820       };
7821     } catch (...) {
7822       {
7823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7824       };
7825     }
7826   }
7827
7828   jresult = (void *)result;
7829   return jresult;
7830 }
7831
7832
7833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7834   void * jresult ;
7835   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7836   float arg2 ;
7837   Dali::Vector4 *result = 0 ;
7838
7839   arg1 = (Dali::Vector4 *)jarg1;
7840   arg2 = (float)jarg2;
7841   {
7842     try {
7843       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7844     } catch (std::out_of_range& e) {
7845       {
7846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7847       };
7848     } catch (std::exception& e) {
7849       {
7850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7851       };
7852     } catch (Dali::DaliException e) {
7853       {
7854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7855       };
7856     } catch (...) {
7857       {
7858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7859       };
7860     }
7861   }
7862
7863   jresult = (void *)result;
7864   return jresult;
7865 }
7866
7867
7868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7869   void * jresult ;
7870   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7871   Dali::Vector4 *arg2 = 0 ;
7872   Dali::Vector4 result;
7873
7874   arg1 = (Dali::Vector4 *)jarg1;
7875   arg2 = (Dali::Vector4 *)jarg2;
7876   if (!arg2) {
7877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7878     return 0;
7879   }
7880   {
7881     try {
7882       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7883     } catch (std::out_of_range& e) {
7884       {
7885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7886       };
7887     } catch (std::exception& e) {
7888       {
7889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7890       };
7891     } catch (Dali::DaliException e) {
7892       {
7893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7894       };
7895     } catch (...) {
7896       {
7897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7898       };
7899     }
7900   }
7901
7902   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7903   return jresult;
7904 }
7905
7906
7907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7908   void * jresult ;
7909   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7910   float arg2 ;
7911   Dali::Vector4 result;
7912
7913   arg1 = (Dali::Vector4 *)jarg1;
7914   arg2 = (float)jarg2;
7915   {
7916     try {
7917       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7918     } catch (std::out_of_range& e) {
7919       {
7920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7921       };
7922     } catch (std::exception& e) {
7923       {
7924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7925       };
7926     } catch (Dali::DaliException e) {
7927       {
7928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7929       };
7930     } catch (...) {
7931       {
7932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7933       };
7934     }
7935   }
7936
7937   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7938   return jresult;
7939 }
7940
7941
7942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7943   void * jresult ;
7944   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7945   Dali::Vector4 *arg2 = 0 ;
7946   Dali::Vector4 *result = 0 ;
7947
7948   arg1 = (Dali::Vector4 *)jarg1;
7949   arg2 = (Dali::Vector4 *)jarg2;
7950   if (!arg2) {
7951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7952     return 0;
7953   }
7954   {
7955     try {
7956       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7957     } catch (std::out_of_range& e) {
7958       {
7959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7960       };
7961     } catch (std::exception& e) {
7962       {
7963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7964       };
7965     } catch (Dali::DaliException e) {
7966       {
7967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7968       };
7969     } catch (...) {
7970       {
7971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7972       };
7973     }
7974   }
7975
7976   jresult = (void *)result;
7977   return jresult;
7978 }
7979
7980
7981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7982   void * jresult ;
7983   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7984   float arg2 ;
7985   Dali::Vector4 *result = 0 ;
7986
7987   arg1 = (Dali::Vector4 *)jarg1;
7988   arg2 = (float)jarg2;
7989   {
7990     try {
7991       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7992     } catch (std::out_of_range& e) {
7993       {
7994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7995       };
7996     } catch (std::exception& e) {
7997       {
7998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7999       };
8000     } catch (Dali::DaliException e) {
8001       {
8002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8003       };
8004     } catch (...) {
8005       {
8006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8007       };
8008     }
8009   }
8010
8011   jresult = (void *)result;
8012   return jresult;
8013 }
8014
8015
8016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8017   void * jresult ;
8018   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8019   Dali::Vector4 result;
8020
8021   arg1 = (Dali::Vector4 *)jarg1;
8022   {
8023     try {
8024       result = ((Dali::Vector4 const *)arg1)->operator -();
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 = new Dali::Vector4((const Dali::Vector4 &)result);
8045   return jresult;
8046 }
8047
8048
8049 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8050   unsigned int jresult ;
8051   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8052   Dali::Vector4 *arg2 = 0 ;
8053   bool result;
8054
8055   arg1 = (Dali::Vector4 *)jarg1;
8056   arg2 = (Dali::Vector4 *)jarg2;
8057   if (!arg2) {
8058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8059     return 0;
8060   }
8061   {
8062     try {
8063       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8064     } catch (std::out_of_range& e) {
8065       {
8066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8067       };
8068     } catch (std::exception& e) {
8069       {
8070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8071       };
8072     } catch (Dali::DaliException e) {
8073       {
8074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8075       };
8076     } catch (...) {
8077       {
8078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8079       };
8080     }
8081   }
8082
8083   jresult = result;
8084   return jresult;
8085 }
8086
8087
8088 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8089   unsigned int jresult ;
8090   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8091   Dali::Vector4 *arg2 = 0 ;
8092   bool result;
8093
8094   arg1 = (Dali::Vector4 *)jarg1;
8095   arg2 = (Dali::Vector4 *)jarg2;
8096   if (!arg2) {
8097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8098     return 0;
8099   }
8100   {
8101     try {
8102       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8103     } catch (std::out_of_range& e) {
8104       {
8105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8106       };
8107     } catch (std::exception& e) {
8108       {
8109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8110       };
8111     } catch (Dali::DaliException e) {
8112       {
8113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8114       };
8115     } catch (...) {
8116       {
8117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8118       };
8119     }
8120   }
8121
8122   jresult = result;
8123   return jresult;
8124 }
8125
8126
8127 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8128   float jresult ;
8129   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8130   unsigned int arg2 ;
8131   float *result = 0 ;
8132
8133   arg1 = (Dali::Vector4 *)jarg1;
8134   arg2 = (unsigned int)jarg2;
8135   {
8136     try {
8137       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8138     } catch (std::out_of_range& e) {
8139       {
8140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8141       };
8142     } catch (std::exception& e) {
8143       {
8144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8145       };
8146     } catch (Dali::DaliException e) {
8147       {
8148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8149       };
8150     } catch (...) {
8151       {
8152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8153       };
8154     }
8155   }
8156
8157   jresult = *result;
8158   return jresult;
8159 }
8160
8161
8162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8163   float jresult ;
8164   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8165   Dali::Vector3 *arg2 = 0 ;
8166   float result;
8167
8168   arg1 = (Dali::Vector4 *)jarg1;
8169   arg2 = (Dali::Vector3 *)jarg2;
8170   if (!arg2) {
8171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8172     return 0;
8173   }
8174   {
8175     try {
8176       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8177     } catch (std::out_of_range& e) {
8178       {
8179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8180       };
8181     } catch (std::exception& e) {
8182       {
8183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8184       };
8185     } catch (Dali::DaliException e) {
8186       {
8187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8188       };
8189     } catch (...) {
8190       {
8191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8192       };
8193     }
8194   }
8195
8196   jresult = result;
8197   return jresult;
8198 }
8199
8200
8201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8202   float jresult ;
8203   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8204   Dali::Vector4 *arg2 = 0 ;
8205   float result;
8206
8207   arg1 = (Dali::Vector4 *)jarg1;
8208   arg2 = (Dali::Vector4 *)jarg2;
8209   if (!arg2) {
8210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8211     return 0;
8212   }
8213   {
8214     try {
8215       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8216     } catch (std::out_of_range& e) {
8217       {
8218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8219       };
8220     } catch (std::exception& e) {
8221       {
8222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8223       };
8224     } catch (Dali::DaliException e) {
8225       {
8226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8227       };
8228     } catch (...) {
8229       {
8230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8231       };
8232     }
8233   }
8234
8235   jresult = result;
8236   return jresult;
8237 }
8238
8239
8240 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8241   float jresult ;
8242   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8243   Dali::Vector4 *arg2 = 0 ;
8244   float result;
8245
8246   arg1 = (Dali::Vector4 *)jarg1;
8247   arg2 = (Dali::Vector4 *)jarg2;
8248   if (!arg2) {
8249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8250     return 0;
8251   }
8252   {
8253     try {
8254       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8255     } catch (std::out_of_range& e) {
8256       {
8257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8258       };
8259     } catch (std::exception& e) {
8260       {
8261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8262       };
8263     } catch (Dali::DaliException e) {
8264       {
8265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8266       };
8267     } catch (...) {
8268       {
8269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8270       };
8271     }
8272   }
8273
8274   jresult = result;
8275   return jresult;
8276 }
8277
8278
8279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8280   void * jresult ;
8281   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8282   Dali::Vector4 *arg2 = 0 ;
8283   Dali::Vector4 result;
8284
8285   arg1 = (Dali::Vector4 *)jarg1;
8286   arg2 = (Dali::Vector4 *)jarg2;
8287   if (!arg2) {
8288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8289     return 0;
8290   }
8291   {
8292     try {
8293       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8294     } catch (std::out_of_range& e) {
8295       {
8296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8297       };
8298     } catch (std::exception& e) {
8299       {
8300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8301       };
8302     } catch (Dali::DaliException e) {
8303       {
8304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8305       };
8306     } catch (...) {
8307       {
8308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8309       };
8310     }
8311   }
8312
8313   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8314   return jresult;
8315 }
8316
8317
8318 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8319   float jresult ;
8320   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8321   float result;
8322
8323   arg1 = (Dali::Vector4 *)jarg1;
8324   {
8325     try {
8326       result = (float)((Dali::Vector4 const *)arg1)->Length();
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 = result;
8347   return jresult;
8348 }
8349
8350
8351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(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)->LengthSquared();
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 void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8385   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8386
8387   arg1 = (Dali::Vector4 *)jarg1;
8388   {
8389     try {
8390       (arg1)->Normalize();
8391     } catch (std::out_of_range& e) {
8392       {
8393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8394       };
8395     } catch (std::exception& e) {
8396       {
8397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8398       };
8399     } catch (Dali::DaliException e) {
8400       {
8401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8402       };
8403     } catch (...) {
8404       {
8405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8406       };
8407     }
8408   }
8409
8410 }
8411
8412
8413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8414   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8415   Dali::Vector4 *arg2 = 0 ;
8416   Dali::Vector4 *arg3 = 0 ;
8417
8418   arg1 = (Dali::Vector4 *)jarg1;
8419   arg2 = (Dali::Vector4 *)jarg2;
8420   if (!arg2) {
8421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8422     return ;
8423   }
8424   arg3 = (Dali::Vector4 *)jarg3;
8425   if (!arg3) {
8426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8427     return ;
8428   }
8429   {
8430     try {
8431       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8432     } catch (std::out_of_range& e) {
8433       {
8434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8435       };
8436     } catch (std::exception& e) {
8437       {
8438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8439       };
8440     } catch (Dali::DaliException e) {
8441       {
8442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8443       };
8444     } catch (...) {
8445       {
8446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8447       };
8448     }
8449   }
8450
8451 }
8452
8453
8454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8455   void * jresult ;
8456   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8457   float *result = 0 ;
8458
8459   arg1 = (Dali::Vector4 *)jarg1;
8460   {
8461     try {
8462       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8463     } catch (std::out_of_range& e) {
8464       {
8465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8466       };
8467     } catch (std::exception& e) {
8468       {
8469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8470       };
8471     } catch (Dali::DaliException e) {
8472       {
8473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8474       };
8475     } catch (...) {
8476       {
8477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8478       };
8479     }
8480   }
8481
8482   jresult = (void *)result;
8483   return jresult;
8484 }
8485
8486
8487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8488   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8489   float arg2 ;
8490
8491   arg1 = (Dali::Vector4 *)jarg1;
8492   arg2 = (float)jarg2;
8493   if (arg1) (arg1)->x = arg2;
8494 }
8495
8496
8497 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8498   float jresult ;
8499   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8500   float result;
8501
8502   arg1 = (Dali::Vector4 *)jarg1;
8503   result = (float) ((arg1)->x);
8504   jresult = result;
8505   return jresult;
8506 }
8507
8508
8509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8510   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8511   float arg2 ;
8512
8513   arg1 = (Dali::Vector4 *)jarg1;
8514   arg2 = (float)jarg2;
8515   if (arg1) (arg1)->r = arg2;
8516 }
8517
8518
8519 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8520   float jresult ;
8521   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8522   float result;
8523
8524   arg1 = (Dali::Vector4 *)jarg1;
8525   result = (float) ((arg1)->r);
8526   jresult = result;
8527   return jresult;
8528 }
8529
8530
8531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8532   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8533   float arg2 ;
8534
8535   arg1 = (Dali::Vector4 *)jarg1;
8536   arg2 = (float)jarg2;
8537   if (arg1) (arg1)->s = arg2;
8538 }
8539
8540
8541 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8542   float jresult ;
8543   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8544   float result;
8545
8546   arg1 = (Dali::Vector4 *)jarg1;
8547   result = (float) ((arg1)->s);
8548   jresult = result;
8549   return jresult;
8550 }
8551
8552
8553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8554   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8555   float arg2 ;
8556
8557   arg1 = (Dali::Vector4 *)jarg1;
8558   arg2 = (float)jarg2;
8559   if (arg1) (arg1)->y = arg2;
8560 }
8561
8562
8563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8564   float jresult ;
8565   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8566   float result;
8567
8568   arg1 = (Dali::Vector4 *)jarg1;
8569   result = (float) ((arg1)->y);
8570   jresult = result;
8571   return jresult;
8572 }
8573
8574
8575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8576   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8577   float arg2 ;
8578
8579   arg1 = (Dali::Vector4 *)jarg1;
8580   arg2 = (float)jarg2;
8581   if (arg1) (arg1)->g = arg2;
8582 }
8583
8584
8585 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8586   float jresult ;
8587   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8588   float result;
8589
8590   arg1 = (Dali::Vector4 *)jarg1;
8591   result = (float) ((arg1)->g);
8592   jresult = result;
8593   return jresult;
8594 }
8595
8596
8597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8598   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8599   float arg2 ;
8600
8601   arg1 = (Dali::Vector4 *)jarg1;
8602   arg2 = (float)jarg2;
8603   if (arg1) (arg1)->t = arg2;
8604 }
8605
8606
8607 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8608   float jresult ;
8609   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8610   float result;
8611
8612   arg1 = (Dali::Vector4 *)jarg1;
8613   result = (float) ((arg1)->t);
8614   jresult = result;
8615   return jresult;
8616 }
8617
8618
8619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8620   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8621   float arg2 ;
8622
8623   arg1 = (Dali::Vector4 *)jarg1;
8624   arg2 = (float)jarg2;
8625   if (arg1) (arg1)->z = arg2;
8626 }
8627
8628
8629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8630   float jresult ;
8631   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8632   float result;
8633
8634   arg1 = (Dali::Vector4 *)jarg1;
8635   result = (float) ((arg1)->z);
8636   jresult = result;
8637   return jresult;
8638 }
8639
8640
8641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8642   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8643   float arg2 ;
8644
8645   arg1 = (Dali::Vector4 *)jarg1;
8646   arg2 = (float)jarg2;
8647   if (arg1) (arg1)->b = arg2;
8648 }
8649
8650
8651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8652   float jresult ;
8653   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8654   float result;
8655
8656   arg1 = (Dali::Vector4 *)jarg1;
8657   result = (float) ((arg1)->b);
8658   jresult = result;
8659   return jresult;
8660 }
8661
8662
8663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8664   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8665   float arg2 ;
8666
8667   arg1 = (Dali::Vector4 *)jarg1;
8668   arg2 = (float)jarg2;
8669   if (arg1) (arg1)->p = arg2;
8670 }
8671
8672
8673 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8674   float jresult ;
8675   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8676   float result;
8677
8678   arg1 = (Dali::Vector4 *)jarg1;
8679   result = (float) ((arg1)->p);
8680   jresult = result;
8681   return jresult;
8682 }
8683
8684
8685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8686   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8687   float arg2 ;
8688
8689   arg1 = (Dali::Vector4 *)jarg1;
8690   arg2 = (float)jarg2;
8691   if (arg1) (arg1)->w = arg2;
8692 }
8693
8694
8695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8696   float jresult ;
8697   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8698   float result;
8699
8700   arg1 = (Dali::Vector4 *)jarg1;
8701   result = (float) ((arg1)->w);
8702   jresult = result;
8703   return jresult;
8704 }
8705
8706
8707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8708   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8709   float arg2 ;
8710
8711   arg1 = (Dali::Vector4 *)jarg1;
8712   arg2 = (float)jarg2;
8713   if (arg1) (arg1)->a = arg2;
8714 }
8715
8716
8717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8718   float jresult ;
8719   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8720   float result;
8721
8722   arg1 = (Dali::Vector4 *)jarg1;
8723   result = (float) ((arg1)->a);
8724   jresult = result;
8725   return jresult;
8726 }
8727
8728
8729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8730   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8731   float arg2 ;
8732
8733   arg1 = (Dali::Vector4 *)jarg1;
8734   arg2 = (float)jarg2;
8735   if (arg1) (arg1)->q = arg2;
8736 }
8737
8738
8739 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8740   float jresult ;
8741   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8742   float result;
8743
8744   arg1 = (Dali::Vector4 *)jarg1;
8745   result = (float) ((arg1)->q);
8746   jresult = result;
8747   return jresult;
8748 }
8749
8750
8751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8752   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8753
8754   arg1 = (Dali::Vector4 *)jarg1;
8755   {
8756     try {
8757       delete arg1;
8758     } catch (std::out_of_range& e) {
8759       {
8760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8761       };
8762     } catch (std::exception& e) {
8763       {
8764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8765       };
8766     } catch (Dali::DaliException e) {
8767       {
8768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8769       };
8770     } catch (...) {
8771       {
8772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8773       };
8774     }
8775   }
8776
8777 }
8778
8779
8780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8781   void * jresult ;
8782   Dali::Vector4 *arg1 = 0 ;
8783   Dali::Vector4 *arg2 = 0 ;
8784   Dali::Vector4 result;
8785
8786   arg1 = (Dali::Vector4 *)jarg1;
8787   if (!arg1) {
8788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8789     return 0;
8790   }
8791   arg2 = (Dali::Vector4 *)jarg2;
8792   if (!arg2) {
8793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8794     return 0;
8795   }
8796   {
8797     try {
8798       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8799     } catch (std::out_of_range& e) {
8800       {
8801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8802       };
8803     } catch (std::exception& e) {
8804       {
8805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8806       };
8807     } catch (Dali::DaliException e) {
8808       {
8809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8810       };
8811     } catch (...) {
8812       {
8813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8814       };
8815     }
8816   }
8817
8818   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8819   return jresult;
8820 }
8821
8822
8823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8824   void * jresult ;
8825   Dali::Vector4 *arg1 = 0 ;
8826   Dali::Vector4 *arg2 = 0 ;
8827   Dali::Vector4 result;
8828
8829   arg1 = (Dali::Vector4 *)jarg1;
8830   if (!arg1) {
8831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8832     return 0;
8833   }
8834   arg2 = (Dali::Vector4 *)jarg2;
8835   if (!arg2) {
8836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8837     return 0;
8838   }
8839   {
8840     try {
8841       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8842     } catch (std::out_of_range& e) {
8843       {
8844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8845       };
8846     } catch (std::exception& e) {
8847       {
8848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8849       };
8850     } catch (Dali::DaliException e) {
8851       {
8852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8853       };
8854     } catch (...) {
8855       {
8856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8857       };
8858     }
8859   }
8860
8861   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8862   return jresult;
8863 }
8864
8865
8866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8867   void * jresult ;
8868   Dali::Vector4 *arg1 = 0 ;
8869   float *arg2 = 0 ;
8870   float *arg3 = 0 ;
8871   float temp2 ;
8872   float temp3 ;
8873   Dali::Vector4 result;
8874
8875   arg1 = (Dali::Vector4 *)jarg1;
8876   if (!arg1) {
8877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8878     return 0;
8879   }
8880   temp2 = (float)jarg2;
8881   arg2 = &temp2;
8882   temp3 = (float)jarg3;
8883   arg3 = &temp3;
8884   {
8885     try {
8886       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8887     } catch (std::out_of_range& e) {
8888       {
8889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8890       };
8891     } catch (std::exception& e) {
8892       {
8893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8894       };
8895     } catch (Dali::DaliException e) {
8896       {
8897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8898       };
8899     } catch (...) {
8900       {
8901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8902       };
8903     }
8904   }
8905
8906   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8907   return jresult;
8908 }
8909
8910
8911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8912   void * jresult ;
8913   Dali::Uint16Pair *result = 0 ;
8914
8915   {
8916     try {
8917       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8918     } catch (std::out_of_range& e) {
8919       {
8920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8921       };
8922     } catch (std::exception& e) {
8923       {
8924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8925       };
8926     } catch (Dali::DaliException e) {
8927       {
8928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8929       };
8930     } catch (...) {
8931       {
8932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8933       };
8934     }
8935   }
8936
8937   jresult = (void *)result;
8938   return jresult;
8939 }
8940
8941
8942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8943   void * jresult ;
8944   uint32_t arg1 ;
8945   uint32_t arg2 ;
8946   Dali::Uint16Pair *result = 0 ;
8947
8948   arg1 = (uint32_t)jarg1;
8949   arg2 = (uint32_t)jarg2;
8950   {
8951     try {
8952       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8953     } catch (std::out_of_range& e) {
8954       {
8955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8956       };
8957     } catch (std::exception& e) {
8958       {
8959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8960       };
8961     } catch (Dali::DaliException e) {
8962       {
8963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8964       };
8965     } catch (...) {
8966       {
8967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8968       };
8969     }
8970   }
8971
8972   jresult = (void *)result;
8973   return jresult;
8974 }
8975
8976
8977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8978   void * jresult ;
8979   Dali::Uint16Pair *arg1 = 0 ;
8980   Dali::Uint16Pair *result = 0 ;
8981
8982   arg1 = (Dali::Uint16Pair *)jarg1;
8983   if (!arg1) {
8984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8985     return 0;
8986   }
8987   {
8988     try {
8989       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8990     } catch (std::out_of_range& e) {
8991       {
8992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8993       };
8994     } catch (std::exception& e) {
8995       {
8996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8997       };
8998     } catch (Dali::DaliException e) {
8999       {
9000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9001       };
9002     } catch (...) {
9003       {
9004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9005       };
9006     }
9007   }
9008
9009   jresult = (void *)result;
9010   return jresult;
9011 }
9012
9013
9014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9015   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9016   uint16_t arg2 ;
9017
9018   arg1 = (Dali::Uint16Pair *)jarg1;
9019   arg2 = (uint16_t)jarg2;
9020   {
9021     try {
9022       (arg1)->SetWidth(arg2);
9023     } catch (std::out_of_range& e) {
9024       {
9025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9026       };
9027     } catch (std::exception& e) {
9028       {
9029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9030       };
9031     } catch (Dali::DaliException e) {
9032       {
9033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9034       };
9035     } catch (...) {
9036       {
9037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9038       };
9039     }
9040   }
9041
9042 }
9043
9044
9045 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9046   unsigned short jresult ;
9047   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9048   uint16_t result;
9049
9050   arg1 = (Dali::Uint16Pair *)jarg1;
9051   {
9052     try {
9053       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9054     } catch (std::out_of_range& e) {
9055       {
9056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9057       };
9058     } catch (std::exception& e) {
9059       {
9060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9061       };
9062     } catch (Dali::DaliException e) {
9063       {
9064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9065       };
9066     } catch (...) {
9067       {
9068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9069       };
9070     }
9071   }
9072
9073   jresult = result;
9074   return jresult;
9075 }
9076
9077
9078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9079   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9080   uint16_t arg2 ;
9081
9082   arg1 = (Dali::Uint16Pair *)jarg1;
9083   arg2 = (uint16_t)jarg2;
9084   {
9085     try {
9086       (arg1)->SetHeight(arg2);
9087     } catch (std::out_of_range& e) {
9088       {
9089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9090       };
9091     } catch (std::exception& e) {
9092       {
9093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9094       };
9095     } catch (Dali::DaliException e) {
9096       {
9097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9098       };
9099     } catch (...) {
9100       {
9101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9102       };
9103     }
9104   }
9105
9106 }
9107
9108
9109 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9110   unsigned short jresult ;
9111   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9112   uint16_t result;
9113
9114   arg1 = (Dali::Uint16Pair *)jarg1;
9115   {
9116     try {
9117       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9118     } catch (std::out_of_range& e) {
9119       {
9120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9121       };
9122     } catch (std::exception& e) {
9123       {
9124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9125       };
9126     } catch (Dali::DaliException e) {
9127       {
9128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9129       };
9130     } catch (...) {
9131       {
9132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9133       };
9134     }
9135   }
9136
9137   jresult = result;
9138   return jresult;
9139 }
9140
9141
9142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9143   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9144   uint16_t arg2 ;
9145
9146   arg1 = (Dali::Uint16Pair *)jarg1;
9147   arg2 = (uint16_t)jarg2;
9148   {
9149     try {
9150       (arg1)->SetX(arg2);
9151     } catch (std::out_of_range& e) {
9152       {
9153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9154       };
9155     } catch (std::exception& e) {
9156       {
9157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9158       };
9159     } catch (Dali::DaliException e) {
9160       {
9161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9162       };
9163     } catch (...) {
9164       {
9165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9166       };
9167     }
9168   }
9169
9170 }
9171
9172
9173 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9174   unsigned short jresult ;
9175   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9176   uint16_t result;
9177
9178   arg1 = (Dali::Uint16Pair *)jarg1;
9179   {
9180     try {
9181       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9182     } catch (std::out_of_range& e) {
9183       {
9184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9185       };
9186     } catch (std::exception& e) {
9187       {
9188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9189       };
9190     } catch (Dali::DaliException e) {
9191       {
9192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9193       };
9194     } catch (...) {
9195       {
9196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9197       };
9198     }
9199   }
9200
9201   jresult = result;
9202   return jresult;
9203 }
9204
9205
9206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9207   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9208   uint16_t arg2 ;
9209
9210   arg1 = (Dali::Uint16Pair *)jarg1;
9211   arg2 = (uint16_t)jarg2;
9212   {
9213     try {
9214       (arg1)->SetY(arg2);
9215     } catch (std::out_of_range& e) {
9216       {
9217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9218       };
9219     } catch (std::exception& e) {
9220       {
9221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9222       };
9223     } catch (Dali::DaliException e) {
9224       {
9225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9226       };
9227     } catch (...) {
9228       {
9229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9230       };
9231     }
9232   }
9233
9234 }
9235
9236
9237 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9238   unsigned short jresult ;
9239   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9240   uint16_t result;
9241
9242   arg1 = (Dali::Uint16Pair *)jarg1;
9243   {
9244     try {
9245       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9246     } catch (std::out_of_range& e) {
9247       {
9248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9249       };
9250     } catch (std::exception& e) {
9251       {
9252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9253       };
9254     } catch (Dali::DaliException e) {
9255       {
9256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9257       };
9258     } catch (...) {
9259       {
9260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9261       };
9262     }
9263   }
9264
9265   jresult = result;
9266   return jresult;
9267 }
9268
9269
9270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9271   void * jresult ;
9272   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9273   Dali::Uint16Pair *arg2 = 0 ;
9274   Dali::Uint16Pair *result = 0 ;
9275
9276   arg1 = (Dali::Uint16Pair *)jarg1;
9277   arg2 = (Dali::Uint16Pair *)jarg2;
9278   if (!arg2) {
9279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9280     return 0;
9281   }
9282   {
9283     try {
9284       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9285     } catch (std::out_of_range& e) {
9286       {
9287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9288       };
9289     } catch (std::exception& e) {
9290       {
9291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9292       };
9293     } catch (Dali::DaliException e) {
9294       {
9295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9296       };
9297     } catch (...) {
9298       {
9299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9300       };
9301     }
9302   }
9303
9304   jresult = (void *)result;
9305   return jresult;
9306 }
9307
9308
9309 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9310   unsigned int jresult ;
9311   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9312   Dali::Uint16Pair *arg2 = 0 ;
9313   bool result;
9314
9315   arg1 = (Dali::Uint16Pair *)jarg1;
9316   arg2 = (Dali::Uint16Pair *)jarg2;
9317   if (!arg2) {
9318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9319     return 0;
9320   }
9321   {
9322     try {
9323       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9324     } catch (std::out_of_range& e) {
9325       {
9326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9327       };
9328     } catch (std::exception& e) {
9329       {
9330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9331       };
9332     } catch (Dali::DaliException e) {
9333       {
9334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9335       };
9336     } catch (...) {
9337       {
9338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9339       };
9340     }
9341   }
9342
9343   jresult = result;
9344   return jresult;
9345 }
9346
9347
9348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9349   unsigned int jresult ;
9350   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9351   Dali::Uint16Pair *arg2 = 0 ;
9352   bool result;
9353
9354   arg1 = (Dali::Uint16Pair *)jarg1;
9355   arg2 = (Dali::Uint16Pair *)jarg2;
9356   if (!arg2) {
9357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9358     return 0;
9359   }
9360   {
9361     try {
9362       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9363     } catch (std::out_of_range& e) {
9364       {
9365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9366       };
9367     } catch (std::exception& e) {
9368       {
9369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9370       };
9371     } catch (Dali::DaliException e) {
9372       {
9373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9374       };
9375     } catch (...) {
9376       {
9377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9378       };
9379     }
9380   }
9381
9382   jresult = result;
9383   return jresult;
9384 }
9385
9386
9387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9388   unsigned int jresult ;
9389   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9390   Dali::Uint16Pair *arg2 = 0 ;
9391   bool result;
9392
9393   arg1 = (Dali::Uint16Pair *)jarg1;
9394   arg2 = (Dali::Uint16Pair *)jarg2;
9395   if (!arg2) {
9396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9397     return 0;
9398   }
9399   {
9400     try {
9401       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9402     } catch (std::out_of_range& e) {
9403       {
9404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9405       };
9406     } catch (std::exception& e) {
9407       {
9408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9409       };
9410     } catch (Dali::DaliException e) {
9411       {
9412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9413       };
9414     } catch (...) {
9415       {
9416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9417       };
9418     }
9419   }
9420
9421   jresult = result;
9422   return jresult;
9423 }
9424
9425
9426 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9427   unsigned int jresult ;
9428   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9429   Dali::Uint16Pair *arg2 = 0 ;
9430   bool result;
9431
9432   arg1 = (Dali::Uint16Pair *)jarg1;
9433   arg2 = (Dali::Uint16Pair *)jarg2;
9434   if (!arg2) {
9435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9436     return 0;
9437   }
9438   {
9439     try {
9440       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9441     } catch (std::out_of_range& e) {
9442       {
9443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9444       };
9445     } catch (std::exception& e) {
9446       {
9447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9448       };
9449     } catch (Dali::DaliException e) {
9450       {
9451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9452       };
9453     } catch (...) {
9454       {
9455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9456       };
9457     }
9458   }
9459
9460   jresult = result;
9461   return jresult;
9462 }
9463
9464
9465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9466   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9467
9468   arg1 = (Dali::Uint16Pair *)jarg1;
9469   {
9470     try {
9471       delete arg1;
9472     } catch (std::out_of_range& e) {
9473       {
9474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9475       };
9476     } catch (std::exception& e) {
9477       {
9478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9479       };
9480     } catch (Dali::DaliException e) {
9481       {
9482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9483       };
9484     } catch (...) {
9485       {
9486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9487       };
9488     }
9489   }
9490
9491 }
9492
9493
9494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9495   void * jresult ;
9496   Dali::Degree *result = 0 ;
9497
9498   {
9499     try {
9500       result = (Dali::Degree *)new Dali::Degree();
9501     } catch (std::out_of_range& e) {
9502       {
9503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9504       };
9505     } catch (std::exception& e) {
9506       {
9507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9508       };
9509     } catch (Dali::DaliException e) {
9510       {
9511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9512       };
9513     } catch (...) {
9514       {
9515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9516       };
9517     }
9518   }
9519
9520   jresult = (void *)result;
9521   return jresult;
9522 }
9523
9524
9525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9526   void * jresult ;
9527   float arg1 ;
9528   Dali::Degree *result = 0 ;
9529
9530   arg1 = (float)jarg1;
9531   {
9532     try {
9533       result = (Dali::Degree *)new Dali::Degree(arg1);
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_2(void * jarg1) {
9559   void * jresult ;
9560   Dali::Radian arg1 ;
9561   Dali::Radian *argp1 ;
9562   Dali::Degree *result = 0 ;
9563
9564   argp1 = (Dali::Radian *)jarg1;
9565   if (!argp1) {
9566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9567     return 0;
9568   }
9569   arg1 = *argp1;
9570   {
9571     try {
9572       result = (Dali::Degree *)new Dali::Degree(arg1);
9573     } catch (std::out_of_range& e) {
9574       {
9575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9576       };
9577     } catch (std::exception& e) {
9578       {
9579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9580       };
9581     } catch (Dali::DaliException e) {
9582       {
9583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9584       };
9585     } catch (...) {
9586       {
9587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9588       };
9589     }
9590   }
9591
9592   jresult = (void *)result;
9593   return jresult;
9594 }
9595
9596
9597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9598   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9599   float arg2 ;
9600
9601   arg1 = (Dali::Degree *)jarg1;
9602   arg2 = (float)jarg2;
9603   if (arg1) (arg1)->degree = arg2;
9604 }
9605
9606
9607 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9608   float jresult ;
9609   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9610   float result;
9611
9612   arg1 = (Dali::Degree *)jarg1;
9613   result = (float) ((arg1)->degree);
9614   jresult = result;
9615   return jresult;
9616 }
9617
9618
9619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9620   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9621
9622   arg1 = (Dali::Degree *)jarg1;
9623   {
9624     try {
9625       delete arg1;
9626     } catch (std::out_of_range& e) {
9627       {
9628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9629       };
9630     } catch (std::exception& e) {
9631       {
9632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9633       };
9634     } catch (Dali::DaliException e) {
9635       {
9636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9637       };
9638     } catch (...) {
9639       {
9640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9641       };
9642     }
9643   }
9644
9645 }
9646
9647
9648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9649   void * jresult ;
9650   Dali::Radian *result = 0 ;
9651
9652   result = (Dali::Radian *)&Dali::ANGLE_360;
9653   jresult = (void *)result;
9654   return jresult;
9655 }
9656
9657
9658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9659   void * jresult ;
9660   Dali::Radian *result = 0 ;
9661
9662   result = (Dali::Radian *)&Dali::ANGLE_315;
9663   jresult = (void *)result;
9664   return jresult;
9665 }
9666
9667
9668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9669   void * jresult ;
9670   Dali::Radian *result = 0 ;
9671
9672   result = (Dali::Radian *)&Dali::ANGLE_270;
9673   jresult = (void *)result;
9674   return jresult;
9675 }
9676
9677
9678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9679   void * jresult ;
9680   Dali::Radian *result = 0 ;
9681
9682   result = (Dali::Radian *)&Dali::ANGLE_225;
9683   jresult = (void *)result;
9684   return jresult;
9685 }
9686
9687
9688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9689   void * jresult ;
9690   Dali::Radian *result = 0 ;
9691
9692   result = (Dali::Radian *)&Dali::ANGLE_180;
9693   jresult = (void *)result;
9694   return jresult;
9695 }
9696
9697
9698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9699   void * jresult ;
9700   Dali::Radian *result = 0 ;
9701
9702   result = (Dali::Radian *)&Dali::ANGLE_135;
9703   jresult = (void *)result;
9704   return jresult;
9705 }
9706
9707
9708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9709   void * jresult ;
9710   Dali::Radian *result = 0 ;
9711
9712   result = (Dali::Radian *)&Dali::ANGLE_120;
9713   jresult = (void *)result;
9714   return jresult;
9715 }
9716
9717
9718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9719   void * jresult ;
9720   Dali::Radian *result = 0 ;
9721
9722   result = (Dali::Radian *)&Dali::ANGLE_90;
9723   jresult = (void *)result;
9724   return jresult;
9725 }
9726
9727
9728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9729   void * jresult ;
9730   Dali::Radian *result = 0 ;
9731
9732   result = (Dali::Radian *)&Dali::ANGLE_60;
9733   jresult = (void *)result;
9734   return jresult;
9735 }
9736
9737
9738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9739   void * jresult ;
9740   Dali::Radian *result = 0 ;
9741
9742   result = (Dali::Radian *)&Dali::ANGLE_45;
9743   jresult = (void *)result;
9744   return jresult;
9745 }
9746
9747
9748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9749   void * jresult ;
9750   Dali::Radian *result = 0 ;
9751
9752   result = (Dali::Radian *)&Dali::ANGLE_30;
9753   jresult = (void *)result;
9754   return jresult;
9755 }
9756
9757
9758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9759   void * jresult ;
9760   Dali::Radian *result = 0 ;
9761
9762   result = (Dali::Radian *)&Dali::ANGLE_0;
9763   jresult = (void *)result;
9764   return jresult;
9765 }
9766
9767
9768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9769   unsigned int jresult ;
9770   Dali::Degree *arg1 = 0 ;
9771   Dali::Degree *arg2 = 0 ;
9772   bool result;
9773
9774   arg1 = (Dali::Degree *)jarg1;
9775   if (!arg1) {
9776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9777     return 0;
9778   }
9779   arg2 = (Dali::Degree *)jarg2;
9780   if (!arg2) {
9781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9782     return 0;
9783   }
9784   {
9785     try {
9786       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9787     } catch (std::out_of_range& e) {
9788       {
9789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9790       };
9791     } catch (std::exception& e) {
9792       {
9793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9794       };
9795     } catch (Dali::DaliException e) {
9796       {
9797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9798       };
9799     } catch (...) {
9800       {
9801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9802       };
9803     }
9804   }
9805
9806   jresult = result;
9807   return jresult;
9808 }
9809
9810
9811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9812   unsigned int jresult ;
9813   Dali::Degree *arg1 = 0 ;
9814   Dali::Degree *arg2 = 0 ;
9815   bool result;
9816
9817   arg1 = (Dali::Degree *)jarg1;
9818   if (!arg1) {
9819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9820     return 0;
9821   }
9822   arg2 = (Dali::Degree *)jarg2;
9823   if (!arg2) {
9824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9825     return 0;
9826   }
9827   {
9828     try {
9829       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9830     } catch (std::out_of_range& e) {
9831       {
9832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9833       };
9834     } catch (std::exception& e) {
9835       {
9836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9837       };
9838     } catch (Dali::DaliException e) {
9839       {
9840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9841       };
9842     } catch (...) {
9843       {
9844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9845       };
9846     }
9847   }
9848
9849   jresult = result;
9850   return jresult;
9851 }
9852
9853
9854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9855   void * jresult ;
9856   Dali::Degree arg1 ;
9857   float arg2 ;
9858   float arg3 ;
9859   Dali::Degree *argp1 ;
9860   Dali::Degree result;
9861
9862   argp1 = (Dali::Degree *)jarg1;
9863   if (!argp1) {
9864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9865     return 0;
9866   }
9867   arg1 = *argp1;
9868   arg2 = (float)jarg2;
9869   arg3 = (float)jarg3;
9870   {
9871     try {
9872       result = Dali::Clamp(arg1,arg2,arg3);
9873     } catch (std::out_of_range& e) {
9874       {
9875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9876       };
9877     } catch (std::exception& e) {
9878       {
9879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9880       };
9881     } catch (Dali::DaliException e) {
9882       {
9883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9884       };
9885     } catch (...) {
9886       {
9887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9888       };
9889     }
9890   }
9891
9892   jresult = new Dali::Degree((const Dali::Degree &)result);
9893   return jresult;
9894 }
9895
9896
9897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9898   void * jresult ;
9899   Dali::Radian *result = 0 ;
9900
9901   {
9902     try {
9903       result = (Dali::Radian *)new Dali::Radian();
9904     } catch (std::out_of_range& e) {
9905       {
9906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9907       };
9908     } catch (std::exception& e) {
9909       {
9910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9911       };
9912     } catch (Dali::DaliException e) {
9913       {
9914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9915       };
9916     } catch (...) {
9917       {
9918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9919       };
9920     }
9921   }
9922
9923   jresult = (void *)result;
9924   return jresult;
9925 }
9926
9927
9928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9929   void * jresult ;
9930   float arg1 ;
9931   Dali::Radian *result = 0 ;
9932
9933   arg1 = (float)jarg1;
9934   {
9935     try {
9936       result = (Dali::Radian *)new Dali::Radian(arg1);
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_2(void * jarg1) {
9962   void * jresult ;
9963   Dali::Degree arg1 ;
9964   Dali::Degree *argp1 ;
9965   Dali::Radian *result = 0 ;
9966
9967   argp1 = (Dali::Degree *)jarg1;
9968   if (!argp1) {
9969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9970     return 0;
9971   }
9972   arg1 = *argp1;
9973   {
9974     try {
9975       result = (Dali::Radian *)new Dali::Radian(arg1);
9976     } catch (std::out_of_range& e) {
9977       {
9978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9979       };
9980     } catch (std::exception& e) {
9981       {
9982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9983       };
9984     } catch (Dali::DaliException e) {
9985       {
9986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9987       };
9988     } catch (...) {
9989       {
9990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9991       };
9992     }
9993   }
9994
9995   jresult = (void *)result;
9996   return jresult;
9997 }
9998
9999
10000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10001   void * jresult ;
10002   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10003   float arg2 ;
10004   Dali::Radian *result = 0 ;
10005
10006   arg1 = (Dali::Radian *)jarg1;
10007   arg2 = (float)jarg2;
10008   {
10009     try {
10010       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10011     } catch (std::out_of_range& e) {
10012       {
10013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10014       };
10015     } catch (std::exception& e) {
10016       {
10017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10018       };
10019     } catch (Dali::DaliException e) {
10020       {
10021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10022       };
10023     } catch (...) {
10024       {
10025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10026       };
10027     }
10028   }
10029
10030   jresult = (void *)result;
10031   return jresult;
10032 }
10033
10034
10035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10036   void * jresult ;
10037   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10038   Dali::Degree arg2 ;
10039   Dali::Degree *argp2 ;
10040   Dali::Radian *result = 0 ;
10041
10042   arg1 = (Dali::Radian *)jarg1;
10043   argp2 = (Dali::Degree *)jarg2;
10044   if (!argp2) {
10045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10046     return 0;
10047   }
10048   arg2 = *argp2;
10049   {
10050     try {
10051       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10052     } catch (std::out_of_range& e) {
10053       {
10054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10055       };
10056     } catch (std::exception& e) {
10057       {
10058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10059       };
10060     } catch (Dali::DaliException e) {
10061       {
10062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10063       };
10064     } catch (...) {
10065       {
10066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10067       };
10068     }
10069   }
10070
10071   jresult = (void *)result;
10072   return jresult;
10073 }
10074
10075
10076 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10077   float jresult ;
10078   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10079   float result;
10080
10081   arg1 = (Dali::Radian *)jarg1;
10082   {
10083     try {
10084       result = (float)((Dali::Radian const *)arg1)->operator float();
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 = result;
10105   return jresult;
10106 }
10107
10108
10109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10110   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10111   float arg2 ;
10112
10113   arg1 = (Dali::Radian *)jarg1;
10114   arg2 = (float)jarg2;
10115   if (arg1) (arg1)->radian = arg2;
10116 }
10117
10118
10119 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10120   float jresult ;
10121   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10122   float result;
10123
10124   arg1 = (Dali::Radian *)jarg1;
10125   result = (float) ((arg1)->radian);
10126   jresult = result;
10127   return jresult;
10128 }
10129
10130
10131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10132   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10133
10134   arg1 = (Dali::Radian *)jarg1;
10135   {
10136     try {
10137       delete arg1;
10138     } catch (std::out_of_range& e) {
10139       {
10140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10141       };
10142     } catch (std::exception& e) {
10143       {
10144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10145       };
10146     } catch (Dali::DaliException e) {
10147       {
10148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10149       };
10150     } catch (...) {
10151       {
10152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10153       };
10154     }
10155   }
10156
10157 }
10158
10159
10160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10161   unsigned int jresult ;
10162   Dali::Radian arg1 ;
10163   Dali::Radian arg2 ;
10164   Dali::Radian *argp1 ;
10165   Dali::Radian *argp2 ;
10166   bool result;
10167
10168   argp1 = (Dali::Radian *)jarg1;
10169   if (!argp1) {
10170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10171     return 0;
10172   }
10173   arg1 = *argp1;
10174   argp2 = (Dali::Radian *)jarg2;
10175   if (!argp2) {
10176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10177     return 0;
10178   }
10179   arg2 = *argp2;
10180   {
10181     try {
10182       result = (bool)Dali::operator ==(arg1,arg2);
10183     } catch (std::out_of_range& e) {
10184       {
10185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10186       };
10187     } catch (std::exception& e) {
10188       {
10189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10190       };
10191     } catch (Dali::DaliException e) {
10192       {
10193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10194       };
10195     } catch (...) {
10196       {
10197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10198       };
10199     }
10200   }
10201
10202   jresult = result;
10203   return jresult;
10204 }
10205
10206
10207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10208   unsigned int jresult ;
10209   Dali::Radian arg1 ;
10210   Dali::Radian arg2 ;
10211   Dali::Radian *argp1 ;
10212   Dali::Radian *argp2 ;
10213   bool result;
10214
10215   argp1 = (Dali::Radian *)jarg1;
10216   if (!argp1) {
10217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10218     return 0;
10219   }
10220   arg1 = *argp1;
10221   argp2 = (Dali::Radian *)jarg2;
10222   if (!argp2) {
10223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10224     return 0;
10225   }
10226   arg2 = *argp2;
10227   {
10228     try {
10229       result = (bool)Dali::operator !=(arg1,arg2);
10230     } catch (std::out_of_range& e) {
10231       {
10232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10233       };
10234     } catch (std::exception& e) {
10235       {
10236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10237       };
10238     } catch (Dali::DaliException e) {
10239       {
10240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10241       };
10242     } catch (...) {
10243       {
10244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10245       };
10246     }
10247   }
10248
10249   jresult = result;
10250   return jresult;
10251 }
10252
10253
10254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10255   unsigned int jresult ;
10256   Dali::Radian arg1 ;
10257   Dali::Degree arg2 ;
10258   Dali::Radian *argp1 ;
10259   Dali::Degree *argp2 ;
10260   bool result;
10261
10262   argp1 = (Dali::Radian *)jarg1;
10263   if (!argp1) {
10264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10265     return 0;
10266   }
10267   arg1 = *argp1;
10268   argp2 = (Dali::Degree *)jarg2;
10269   if (!argp2) {
10270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10271     return 0;
10272   }
10273   arg2 = *argp2;
10274   {
10275     try {
10276       result = (bool)Dali::operator ==(arg1,arg2);
10277     } catch (std::out_of_range& e) {
10278       {
10279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10280       };
10281     } catch (std::exception& e) {
10282       {
10283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10284       };
10285     } catch (Dali::DaliException e) {
10286       {
10287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10288       };
10289     } catch (...) {
10290       {
10291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10292       };
10293     }
10294   }
10295
10296   jresult = result;
10297   return jresult;
10298 }
10299
10300
10301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10302   unsigned int jresult ;
10303   Dali::Radian arg1 ;
10304   Dali::Degree arg2 ;
10305   Dali::Radian *argp1 ;
10306   Dali::Degree *argp2 ;
10307   bool result;
10308
10309   argp1 = (Dali::Radian *)jarg1;
10310   if (!argp1) {
10311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10312     return 0;
10313   }
10314   arg1 = *argp1;
10315   argp2 = (Dali::Degree *)jarg2;
10316   if (!argp2) {
10317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10318     return 0;
10319   }
10320   arg2 = *argp2;
10321   {
10322     try {
10323       result = (bool)Dali::operator !=(arg1,arg2);
10324     } catch (std::out_of_range& e) {
10325       {
10326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10327       };
10328     } catch (std::exception& e) {
10329       {
10330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10331       };
10332     } catch (Dali::DaliException e) {
10333       {
10334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10335       };
10336     } catch (...) {
10337       {
10338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10339       };
10340     }
10341   }
10342
10343   jresult = result;
10344   return jresult;
10345 }
10346
10347
10348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10349   unsigned int jresult ;
10350   Dali::Degree arg1 ;
10351   Dali::Radian arg2 ;
10352   Dali::Degree *argp1 ;
10353   Dali::Radian *argp2 ;
10354   bool result;
10355
10356   argp1 = (Dali::Degree *)jarg1;
10357   if (!argp1) {
10358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10359     return 0;
10360   }
10361   arg1 = *argp1;
10362   argp2 = (Dali::Radian *)jarg2;
10363   if (!argp2) {
10364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10365     return 0;
10366   }
10367   arg2 = *argp2;
10368   {
10369     try {
10370       result = (bool)Dali::operator ==(arg1,arg2);
10371     } catch (std::out_of_range& e) {
10372       {
10373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10374       };
10375     } catch (std::exception& e) {
10376       {
10377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10378       };
10379     } catch (Dali::DaliException e) {
10380       {
10381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10382       };
10383     } catch (...) {
10384       {
10385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10386       };
10387     }
10388   }
10389
10390   jresult = result;
10391   return jresult;
10392 }
10393
10394
10395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10396   unsigned int jresult ;
10397   Dali::Degree arg1 ;
10398   Dali::Radian arg2 ;
10399   Dali::Degree *argp1 ;
10400   Dali::Radian *argp2 ;
10401   bool result;
10402
10403   argp1 = (Dali::Degree *)jarg1;
10404   if (!argp1) {
10405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10406     return 0;
10407   }
10408   arg1 = *argp1;
10409   argp2 = (Dali::Radian *)jarg2;
10410   if (!argp2) {
10411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10412     return 0;
10413   }
10414   arg2 = *argp2;
10415   {
10416     try {
10417       result = (bool)Dali::operator !=(arg1,arg2);
10418     } catch (std::out_of_range& e) {
10419       {
10420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10421       };
10422     } catch (std::exception& e) {
10423       {
10424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10425       };
10426     } catch (Dali::DaliException e) {
10427       {
10428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10429       };
10430     } catch (...) {
10431       {
10432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10433       };
10434     }
10435   }
10436
10437   jresult = result;
10438   return jresult;
10439 }
10440
10441
10442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10443   unsigned int jresult ;
10444   Dali::Radian arg1 ;
10445   Dali::Radian arg2 ;
10446   Dali::Radian *argp1 ;
10447   Dali::Radian *argp2 ;
10448   bool result;
10449
10450   argp1 = (Dali::Radian *)jarg1;
10451   if (!argp1) {
10452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10453     return 0;
10454   }
10455   arg1 = *argp1;
10456   argp2 = (Dali::Radian *)jarg2;
10457   if (!argp2) {
10458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10459     return 0;
10460   }
10461   arg2 = *argp2;
10462   {
10463     try {
10464       result = (bool)Dali::operator >(arg1,arg2);
10465     } catch (std::out_of_range& e) {
10466       {
10467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10468       };
10469     } catch (std::exception& e) {
10470       {
10471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10472       };
10473     } catch (Dali::DaliException e) {
10474       {
10475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10476       };
10477     } catch (...) {
10478       {
10479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10480       };
10481     }
10482   }
10483
10484   jresult = result;
10485   return jresult;
10486 }
10487
10488
10489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10490   unsigned int jresult ;
10491   Dali::Radian arg1 ;
10492   Dali::Degree arg2 ;
10493   Dali::Radian *argp1 ;
10494   Dali::Degree *argp2 ;
10495   bool result;
10496
10497   argp1 = (Dali::Radian *)jarg1;
10498   if (!argp1) {
10499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10500     return 0;
10501   }
10502   arg1 = *argp1;
10503   argp2 = (Dali::Degree *)jarg2;
10504   if (!argp2) {
10505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10506     return 0;
10507   }
10508   arg2 = *argp2;
10509   {
10510     try {
10511       result = (bool)Dali::operator >(arg1,arg2);
10512     } catch (std::out_of_range& e) {
10513       {
10514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10515       };
10516     } catch (std::exception& e) {
10517       {
10518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10519       };
10520     } catch (Dali::DaliException e) {
10521       {
10522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10523       };
10524     } catch (...) {
10525       {
10526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10527       };
10528     }
10529   }
10530
10531   jresult = result;
10532   return jresult;
10533 }
10534
10535
10536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10537   unsigned int jresult ;
10538   Dali::Degree arg1 ;
10539   Dali::Radian arg2 ;
10540   Dali::Degree *argp1 ;
10541   Dali::Radian *argp2 ;
10542   bool result;
10543
10544   argp1 = (Dali::Degree *)jarg1;
10545   if (!argp1) {
10546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10547     return 0;
10548   }
10549   arg1 = *argp1;
10550   argp2 = (Dali::Radian *)jarg2;
10551   if (!argp2) {
10552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10553     return 0;
10554   }
10555   arg2 = *argp2;
10556   {
10557     try {
10558       result = (bool)Dali::operator >(arg1,arg2);
10559     } catch (std::out_of_range& e) {
10560       {
10561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10562       };
10563     } catch (std::exception& e) {
10564       {
10565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10566       };
10567     } catch (Dali::DaliException e) {
10568       {
10569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10570       };
10571     } catch (...) {
10572       {
10573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10574       };
10575     }
10576   }
10577
10578   jresult = result;
10579   return jresult;
10580 }
10581
10582
10583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10584   unsigned int jresult ;
10585   Dali::Radian arg1 ;
10586   Dali::Radian arg2 ;
10587   Dali::Radian *argp1 ;
10588   Dali::Radian *argp2 ;
10589   bool result;
10590
10591   argp1 = (Dali::Radian *)jarg1;
10592   if (!argp1) {
10593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10594     return 0;
10595   }
10596   arg1 = *argp1;
10597   argp2 = (Dali::Radian *)jarg2;
10598   if (!argp2) {
10599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10600     return 0;
10601   }
10602   arg2 = *argp2;
10603   {
10604     try {
10605       result = (bool)Dali::operator <(arg1,arg2);
10606     } catch (std::out_of_range& e) {
10607       {
10608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10609       };
10610     } catch (std::exception& e) {
10611       {
10612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10613       };
10614     } catch (Dali::DaliException e) {
10615       {
10616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10617       };
10618     } catch (...) {
10619       {
10620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10621       };
10622     }
10623   }
10624
10625   jresult = result;
10626   return jresult;
10627 }
10628
10629
10630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10631   unsigned int jresult ;
10632   Dali::Radian arg1 ;
10633   Dali::Degree arg2 ;
10634   Dali::Radian *argp1 ;
10635   Dali::Degree *argp2 ;
10636   bool result;
10637
10638   argp1 = (Dali::Radian *)jarg1;
10639   if (!argp1) {
10640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10641     return 0;
10642   }
10643   arg1 = *argp1;
10644   argp2 = (Dali::Degree *)jarg2;
10645   if (!argp2) {
10646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10647     return 0;
10648   }
10649   arg2 = *argp2;
10650   {
10651     try {
10652       result = (bool)Dali::operator <(arg1,arg2);
10653     } catch (std::out_of_range& e) {
10654       {
10655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10656       };
10657     } catch (std::exception& e) {
10658       {
10659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10660       };
10661     } catch (Dali::DaliException e) {
10662       {
10663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10664       };
10665     } catch (...) {
10666       {
10667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10668       };
10669     }
10670   }
10671
10672   jresult = result;
10673   return jresult;
10674 }
10675
10676
10677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10678   unsigned int jresult ;
10679   Dali::Degree arg1 ;
10680   Dali::Radian arg2 ;
10681   Dali::Degree *argp1 ;
10682   Dali::Radian *argp2 ;
10683   bool result;
10684
10685   argp1 = (Dali::Degree *)jarg1;
10686   if (!argp1) {
10687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10688     return 0;
10689   }
10690   arg1 = *argp1;
10691   argp2 = (Dali::Radian *)jarg2;
10692   if (!argp2) {
10693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10694     return 0;
10695   }
10696   arg2 = *argp2;
10697   {
10698     try {
10699       result = (bool)Dali::operator <(arg1,arg2);
10700     } catch (std::out_of_range& e) {
10701       {
10702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10703       };
10704     } catch (std::exception& e) {
10705       {
10706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10707       };
10708     } catch (Dali::DaliException e) {
10709       {
10710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10711       };
10712     } catch (...) {
10713       {
10714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10715       };
10716     }
10717   }
10718
10719   jresult = result;
10720   return jresult;
10721 }
10722
10723
10724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10725   void * jresult ;
10726   Dali::Radian arg1 ;
10727   float arg2 ;
10728   Dali::Radian *argp1 ;
10729   Dali::Radian result;
10730
10731   argp1 = (Dali::Radian *)jarg1;
10732   if (!argp1) {
10733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10734     return 0;
10735   }
10736   arg1 = *argp1;
10737   arg2 = (float)jarg2;
10738   {
10739     try {
10740       result = Dali::operator *(arg1,arg2);
10741     } catch (std::out_of_range& e) {
10742       {
10743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10744       };
10745     } catch (std::exception& e) {
10746       {
10747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10748       };
10749     } catch (Dali::DaliException e) {
10750       {
10751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10752       };
10753     } catch (...) {
10754       {
10755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10756       };
10757     }
10758   }
10759
10760   jresult = new Dali::Radian((const Dali::Radian &)result);
10761   return jresult;
10762 }
10763
10764
10765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10766   void * jresult ;
10767   Dali::Radian arg1 ;
10768   Dali::Radian *argp1 ;
10769   Dali::Radian result;
10770
10771   argp1 = (Dali::Radian *)jarg1;
10772   if (!argp1) {
10773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10774     return 0;
10775   }
10776   arg1 = *argp1;
10777   {
10778     try {
10779       result = Dali::operator -(arg1);
10780     } catch (std::out_of_range& e) {
10781       {
10782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10783       };
10784     } catch (std::exception& e) {
10785       {
10786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10787       };
10788     } catch (Dali::DaliException e) {
10789       {
10790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10791       };
10792     } catch (...) {
10793       {
10794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10795       };
10796     }
10797   }
10798
10799   jresult = new Dali::Radian((const Dali::Radian &)result);
10800   return jresult;
10801 }
10802
10803
10804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10805   void * jresult ;
10806   Dali::Radian arg1 ;
10807   float arg2 ;
10808   float arg3 ;
10809   Dali::Radian *argp1 ;
10810   Dali::Radian result;
10811
10812   argp1 = (Dali::Radian *)jarg1;
10813   if (!argp1) {
10814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10815     return 0;
10816   }
10817   arg1 = *argp1;
10818   arg2 = (float)jarg2;
10819   arg3 = (float)jarg3;
10820   {
10821     try {
10822       result = Dali::Clamp(arg1,arg2,arg3);
10823     } catch (std::out_of_range& e) {
10824       {
10825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10826       };
10827     } catch (std::exception& e) {
10828       {
10829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10830       };
10831     } catch (Dali::DaliException e) {
10832       {
10833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10834       };
10835     } catch (...) {
10836       {
10837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10838       };
10839     }
10840   }
10841
10842   jresult = new Dali::Radian((const Dali::Radian &)result);
10843   return jresult;
10844 }
10845
10846
10847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10848   void * jresult ;
10849   Dali::Quaternion *result = 0 ;
10850
10851   {
10852     try {
10853       result = (Dali::Quaternion *)new Dali::Quaternion();
10854     } catch (std::out_of_range& e) {
10855       {
10856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10857       };
10858     } catch (std::exception& e) {
10859       {
10860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10861       };
10862     } catch (Dali::DaliException e) {
10863       {
10864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10865       };
10866     } catch (...) {
10867       {
10868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10869       };
10870     }
10871   }
10872
10873   jresult = (void *)result;
10874   return jresult;
10875 }
10876
10877
10878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10879   void * jresult ;
10880   Dali::Radian arg1 ;
10881   Dali::Vector3 *arg2 = 0 ;
10882   Dali::Radian *argp1 ;
10883   Dali::Quaternion *result = 0 ;
10884
10885   argp1 = (Dali::Radian *)jarg1;
10886   if (!argp1) {
10887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10888     return 0;
10889   }
10890   arg1 = *argp1;
10891   arg2 = (Dali::Vector3 *)jarg2;
10892   if (!arg2) {
10893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10894     return 0;
10895   }
10896   {
10897     try {
10898       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10899     } catch (std::out_of_range& e) {
10900       {
10901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10902       };
10903     } catch (std::exception& e) {
10904       {
10905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10906       };
10907     } catch (Dali::DaliException e) {
10908       {
10909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10910       };
10911     } catch (...) {
10912       {
10913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10914       };
10915     }
10916   }
10917
10918   jresult = (void *)result;
10919   return jresult;
10920 }
10921
10922
10923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10924   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10925
10926   arg1 = (Dali::Quaternion *)jarg1;
10927   {
10928     try {
10929       delete arg1;
10930     } catch (std::out_of_range& e) {
10931       {
10932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10933       };
10934     } catch (std::exception& e) {
10935       {
10936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10937       };
10938     } catch (Dali::DaliException e) {
10939       {
10940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10941       };
10942     } catch (...) {
10943       {
10944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10945       };
10946     }
10947   }
10948
10949 }
10950
10951
10952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10953   void * jresult ;
10954   Dali::Quaternion *result = 0 ;
10955
10956   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
10957   jresult = (void *)result;
10958   return jresult;
10959 }
10960
10961
10962 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
10963   unsigned int jresult ;
10964   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10965   bool result;
10966
10967   arg1 = (Dali::Quaternion *)jarg1;
10968   {
10969     try {
10970       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
10971     } catch (std::out_of_range& e) {
10972       {
10973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10974       };
10975     } catch (std::exception& e) {
10976       {
10977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10978       };
10979     } catch (Dali::DaliException e) {
10980       {
10981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10982       };
10983     } catch (...) {
10984       {
10985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10986       };
10987     }
10988   }
10989
10990   jresult = result;
10991   return jresult;
10992 }
10993
10994
10995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
10996   unsigned int jresult ;
10997   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10998   Dali::Vector3 *arg2 = 0 ;
10999   Dali::Radian *arg3 = 0 ;
11000   bool result;
11001
11002   arg1 = (Dali::Quaternion *)jarg1;
11003   arg2 = (Dali::Vector3 *)jarg2;
11004   if (!arg2) {
11005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11006     return 0;
11007   }
11008   arg3 = (Dali::Radian *)jarg3;
11009   if (!arg3) {
11010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11011     return 0;
11012   }
11013   {
11014     try {
11015       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11016     } catch (std::out_of_range& e) {
11017       {
11018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11019       };
11020     } catch (std::exception& e) {
11021       {
11022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11023       };
11024     } catch (Dali::DaliException e) {
11025       {
11026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11027       };
11028     } catch (...) {
11029       {
11030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11031       };
11032     }
11033   }
11034
11035   jresult = result;
11036   return jresult;
11037 }
11038
11039
11040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11041   void * jresult ;
11042   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11043   Dali::Quaternion *arg2 = 0 ;
11044   Dali::Quaternion result;
11045
11046   arg1 = (Dali::Quaternion *)jarg1;
11047   arg2 = (Dali::Quaternion *)jarg2;
11048   if (!arg2) {
11049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11050     return 0;
11051   }
11052   {
11053     try {
11054       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11055     } catch (std::out_of_range& e) {
11056       {
11057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11058       };
11059     } catch (std::exception& e) {
11060       {
11061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11062       };
11063     } catch (Dali::DaliException e) {
11064       {
11065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11066       };
11067     } catch (...) {
11068       {
11069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11070       };
11071     }
11072   }
11073
11074   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11075   return jresult;
11076 }
11077
11078
11079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11080   void * jresult ;
11081   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11082   Dali::Quaternion *arg2 = 0 ;
11083   Dali::Quaternion result;
11084
11085   arg1 = (Dali::Quaternion *)jarg1;
11086   arg2 = (Dali::Quaternion *)jarg2;
11087   if (!arg2) {
11088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11089     return 0;
11090   }
11091   {
11092     try {
11093       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11094     } catch (std::out_of_range& e) {
11095       {
11096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11097       };
11098     } catch (std::exception& e) {
11099       {
11100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11101       };
11102     } catch (Dali::DaliException e) {
11103       {
11104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11105       };
11106     } catch (...) {
11107       {
11108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11109       };
11110     }
11111   }
11112
11113   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11114   return jresult;
11115 }
11116
11117
11118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11119   void * jresult ;
11120   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11121   Dali::Quaternion *arg2 = 0 ;
11122   Dali::Quaternion result;
11123
11124   arg1 = (Dali::Quaternion *)jarg1;
11125   arg2 = (Dali::Quaternion *)jarg2;
11126   if (!arg2) {
11127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11128     return 0;
11129   }
11130   {
11131     try {
11132       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11133     } catch (std::out_of_range& e) {
11134       {
11135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11136       };
11137     } catch (std::exception& e) {
11138       {
11139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11140       };
11141     } catch (Dali::DaliException e) {
11142       {
11143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11144       };
11145     } catch (...) {
11146       {
11147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11148       };
11149     }
11150   }
11151
11152   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11153   return jresult;
11154 }
11155
11156
11157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11158   void * jresult ;
11159   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11160   Dali::Vector3 *arg2 = 0 ;
11161   Dali::Vector3 result;
11162
11163   arg1 = (Dali::Quaternion *)jarg1;
11164   arg2 = (Dali::Vector3 *)jarg2;
11165   if (!arg2) {
11166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11167     return 0;
11168   }
11169   {
11170     try {
11171       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11172     } catch (std::out_of_range& e) {
11173       {
11174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11175       };
11176     } catch (std::exception& e) {
11177       {
11178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11179       };
11180     } catch (Dali::DaliException e) {
11181       {
11182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11183       };
11184     } catch (...) {
11185       {
11186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11187       };
11188     }
11189   }
11190
11191   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11192   return jresult;
11193 }
11194
11195
11196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11197   void * jresult ;
11198   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11199   Dali::Quaternion *arg2 = 0 ;
11200   Dali::Quaternion result;
11201
11202   arg1 = (Dali::Quaternion *)jarg1;
11203   arg2 = (Dali::Quaternion *)jarg2;
11204   if (!arg2) {
11205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11206     return 0;
11207   }
11208   {
11209     try {
11210       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11211     } catch (std::out_of_range& e) {
11212       {
11213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11214       };
11215     } catch (std::exception& e) {
11216       {
11217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11218       };
11219     } catch (Dali::DaliException e) {
11220       {
11221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11222       };
11223     } catch (...) {
11224       {
11225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11226       };
11227     }
11228   }
11229
11230   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11231   return jresult;
11232 }
11233
11234
11235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11236   void * jresult ;
11237   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11238   float arg2 ;
11239   Dali::Quaternion result;
11240
11241   arg1 = (Dali::Quaternion *)jarg1;
11242   arg2 = (float)jarg2;
11243   {
11244     try {
11245       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11246     } catch (std::out_of_range& e) {
11247       {
11248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11249       };
11250     } catch (std::exception& e) {
11251       {
11252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11253       };
11254     } catch (Dali::DaliException e) {
11255       {
11256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11257       };
11258     } catch (...) {
11259       {
11260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11261       };
11262     }
11263   }
11264
11265   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11266   return jresult;
11267 }
11268
11269
11270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11271   void * jresult ;
11272   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11273   float arg2 ;
11274   Dali::Quaternion result;
11275
11276   arg1 = (Dali::Quaternion *)jarg1;
11277   arg2 = (float)jarg2;
11278   {
11279     try {
11280       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11281     } catch (std::out_of_range& e) {
11282       {
11283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11284       };
11285     } catch (std::exception& e) {
11286       {
11287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11288       };
11289     } catch (Dali::DaliException e) {
11290       {
11291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11292       };
11293     } catch (...) {
11294       {
11295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11296       };
11297     }
11298   }
11299
11300   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11301   return jresult;
11302 }
11303
11304
11305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11306   void * jresult ;
11307   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11308   Dali::Quaternion result;
11309
11310   arg1 = (Dali::Quaternion *)jarg1;
11311   {
11312     try {
11313       result = ((Dali::Quaternion const *)arg1)->operator -();
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_AddAssign(void * jarg1, void * jarg2) {
11339   void * jresult ;
11340   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11341   Dali::Quaternion *arg2 = 0 ;
11342   Dali::Quaternion *result = 0 ;
11343
11344   arg1 = (Dali::Quaternion *)jarg1;
11345   arg2 = (Dali::Quaternion *)jarg2;
11346   if (!arg2) {
11347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11348     return 0;
11349   }
11350   {
11351     try {
11352       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11353     } catch (std::out_of_range& e) {
11354       {
11355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11356       };
11357     } catch (std::exception& e) {
11358       {
11359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11360       };
11361     } catch (Dali::DaliException e) {
11362       {
11363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11364       };
11365     } catch (...) {
11366       {
11367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11368       };
11369     }
11370   }
11371
11372   jresult = (void *)result;
11373   return jresult;
11374 }
11375
11376
11377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11378   void * jresult ;
11379   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11380   Dali::Quaternion *arg2 = 0 ;
11381   Dali::Quaternion *result = 0 ;
11382
11383   arg1 = (Dali::Quaternion *)jarg1;
11384   arg2 = (Dali::Quaternion *)jarg2;
11385   if (!arg2) {
11386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11387     return 0;
11388   }
11389   {
11390     try {
11391       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11392     } catch (std::out_of_range& e) {
11393       {
11394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11395       };
11396     } catch (std::exception& e) {
11397       {
11398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11399       };
11400     } catch (Dali::DaliException e) {
11401       {
11402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11403       };
11404     } catch (...) {
11405       {
11406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11407       };
11408     }
11409   }
11410
11411   jresult = (void *)result;
11412   return jresult;
11413 }
11414
11415
11416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11417   void * jresult ;
11418   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11419   Dali::Quaternion *arg2 = 0 ;
11420   Dali::Quaternion *result = 0 ;
11421
11422   arg1 = (Dali::Quaternion *)jarg1;
11423   arg2 = (Dali::Quaternion *)jarg2;
11424   if (!arg2) {
11425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11426     return 0;
11427   }
11428   {
11429     try {
11430       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11431     } catch (std::out_of_range& e) {
11432       {
11433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11434       };
11435     } catch (std::exception& e) {
11436       {
11437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11438       };
11439     } catch (Dali::DaliException e) {
11440       {
11441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11442       };
11443     } catch (...) {
11444       {
11445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11446       };
11447     }
11448   }
11449
11450   jresult = (void *)result;
11451   return jresult;
11452 }
11453
11454
11455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11456   void * jresult ;
11457   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11458   float arg2 ;
11459   Dali::Quaternion *result = 0 ;
11460
11461   arg1 = (Dali::Quaternion *)jarg1;
11462   arg2 = (float)jarg2;
11463   {
11464     try {
11465       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11466     } catch (std::out_of_range& e) {
11467       {
11468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11469       };
11470     } catch (std::exception& e) {
11471       {
11472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11473       };
11474     } catch (Dali::DaliException e) {
11475       {
11476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11477       };
11478     } catch (...) {
11479       {
11480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11481       };
11482     }
11483   }
11484
11485   jresult = (void *)result;
11486   return jresult;
11487 }
11488
11489
11490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11491   void * jresult ;
11492   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11493   float arg2 ;
11494   Dali::Quaternion *result = 0 ;
11495
11496   arg1 = (Dali::Quaternion *)jarg1;
11497   arg2 = (float)jarg2;
11498   {
11499     try {
11500       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11501     } catch (std::out_of_range& e) {
11502       {
11503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11504       };
11505     } catch (std::exception& e) {
11506       {
11507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11508       };
11509     } catch (Dali::DaliException e) {
11510       {
11511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11512       };
11513     } catch (...) {
11514       {
11515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11516       };
11517     }
11518   }
11519
11520   jresult = (void *)result;
11521   return jresult;
11522 }
11523
11524
11525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11526   unsigned int jresult ;
11527   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11528   Dali::Quaternion *arg2 = 0 ;
11529   bool result;
11530
11531   arg1 = (Dali::Quaternion *)jarg1;
11532   arg2 = (Dali::Quaternion *)jarg2;
11533   if (!arg2) {
11534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11535     return 0;
11536   }
11537   {
11538     try {
11539       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11540     } catch (std::out_of_range& e) {
11541       {
11542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11543       };
11544     } catch (std::exception& e) {
11545       {
11546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11547       };
11548     } catch (Dali::DaliException e) {
11549       {
11550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11551       };
11552     } catch (...) {
11553       {
11554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11555       };
11556     }
11557   }
11558
11559   jresult = result;
11560   return jresult;
11561 }
11562
11563
11564 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11565   unsigned int jresult ;
11566   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11567   Dali::Quaternion *arg2 = 0 ;
11568   bool result;
11569
11570   arg1 = (Dali::Quaternion *)jarg1;
11571   arg2 = (Dali::Quaternion *)jarg2;
11572   if (!arg2) {
11573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11574     return 0;
11575   }
11576   {
11577     try {
11578       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11579     } catch (std::out_of_range& e) {
11580       {
11581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11582       };
11583     } catch (std::exception& e) {
11584       {
11585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11586       };
11587     } catch (Dali::DaliException e) {
11588       {
11589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11590       };
11591     } catch (...) {
11592       {
11593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11594       };
11595     }
11596   }
11597
11598   jresult = result;
11599   return jresult;
11600 }
11601
11602
11603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11604   float jresult ;
11605   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11606   float result;
11607
11608   arg1 = (Dali::Quaternion *)jarg1;
11609   {
11610     try {
11611       result = (float)((Dali::Quaternion const *)arg1)->Length();
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_LengthSquared(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)->LengthSquared();
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 void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11670   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11671
11672   arg1 = (Dali::Quaternion *)jarg1;
11673   {
11674     try {
11675       (arg1)->Normalize();
11676     } catch (std::out_of_range& e) {
11677       {
11678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11679       };
11680     } catch (std::exception& e) {
11681       {
11682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11683       };
11684     } catch (Dali::DaliException e) {
11685       {
11686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11687       };
11688     } catch (...) {
11689       {
11690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11691       };
11692     }
11693   }
11694
11695 }
11696
11697
11698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11699   void * jresult ;
11700   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11701   Dali::Quaternion result;
11702
11703   arg1 = (Dali::Quaternion *)jarg1;
11704   {
11705     try {
11706       result = ((Dali::Quaternion const *)arg1)->Normalized();
11707     } catch (std::out_of_range& e) {
11708       {
11709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11710       };
11711     } catch (std::exception& e) {
11712       {
11713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11714       };
11715     } catch (Dali::DaliException e) {
11716       {
11717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11718       };
11719     } catch (...) {
11720       {
11721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11722       };
11723     }
11724   }
11725
11726   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11727   return jresult;
11728 }
11729
11730
11731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11732   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11733
11734   arg1 = (Dali::Quaternion *)jarg1;
11735   {
11736     try {
11737       (arg1)->Conjugate();
11738     } catch (std::out_of_range& e) {
11739       {
11740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11741       };
11742     } catch (std::exception& e) {
11743       {
11744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11745       };
11746     } catch (Dali::DaliException e) {
11747       {
11748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11749       };
11750     } catch (...) {
11751       {
11752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11753       };
11754     }
11755   }
11756
11757 }
11758
11759
11760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11761   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11762
11763   arg1 = (Dali::Quaternion *)jarg1;
11764   {
11765     try {
11766       (arg1)->Invert();
11767     } catch (std::out_of_range& e) {
11768       {
11769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11770       };
11771     } catch (std::exception& e) {
11772       {
11773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11774       };
11775     } catch (Dali::DaliException e) {
11776       {
11777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11778       };
11779     } catch (...) {
11780       {
11781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11782       };
11783     }
11784   }
11785
11786 }
11787
11788
11789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11790   void * jresult ;
11791   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11792   Dali::Quaternion result;
11793
11794   arg1 = (Dali::Quaternion *)jarg1;
11795   {
11796     try {
11797       result = ((Dali::Quaternion const *)arg1)->Log();
11798     } catch (std::out_of_range& e) {
11799       {
11800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11801       };
11802     } catch (std::exception& e) {
11803       {
11804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11805       };
11806     } catch (Dali::DaliException e) {
11807       {
11808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11809       };
11810     } catch (...) {
11811       {
11812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11813       };
11814     }
11815   }
11816
11817   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11818   return jresult;
11819 }
11820
11821
11822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(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)->Exp();
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 float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11856   float jresult ;
11857   Dali::Quaternion *arg1 = 0 ;
11858   Dali::Quaternion *arg2 = 0 ;
11859   float result;
11860
11861   arg1 = (Dali::Quaternion *)jarg1;
11862   if (!arg1) {
11863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11864     return 0;
11865   }
11866   arg2 = (Dali::Quaternion *)jarg2;
11867   if (!arg2) {
11868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11869     return 0;
11870   }
11871   {
11872     try {
11873       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11874     } catch (std::out_of_range& e) {
11875       {
11876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11877       };
11878     } catch (std::exception& e) {
11879       {
11880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11881       };
11882     } catch (Dali::DaliException e) {
11883       {
11884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11885       };
11886     } catch (...) {
11887       {
11888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11889       };
11890     }
11891   }
11892
11893   jresult = result;
11894   return jresult;
11895 }
11896
11897
11898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11899   void * jresult ;
11900   Dali::Quaternion *arg1 = 0 ;
11901   Dali::Quaternion *arg2 = 0 ;
11902   float arg3 ;
11903   Dali::Quaternion result;
11904
11905   arg1 = (Dali::Quaternion *)jarg1;
11906   if (!arg1) {
11907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11908     return 0;
11909   }
11910   arg2 = (Dali::Quaternion *)jarg2;
11911   if (!arg2) {
11912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11913     return 0;
11914   }
11915   arg3 = (float)jarg3;
11916   {
11917     try {
11918       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11919     } catch (std::out_of_range& e) {
11920       {
11921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11922       };
11923     } catch (std::exception& e) {
11924       {
11925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11926       };
11927     } catch (Dali::DaliException e) {
11928       {
11929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11930       };
11931     } catch (...) {
11932       {
11933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11934       };
11935     }
11936   }
11937
11938   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11939   return jresult;
11940 }
11941
11942
11943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11944   void * jresult ;
11945   Dali::Quaternion *arg1 = 0 ;
11946   Dali::Quaternion *arg2 = 0 ;
11947   float arg3 ;
11948   Dali::Quaternion result;
11949
11950   arg1 = (Dali::Quaternion *)jarg1;
11951   if (!arg1) {
11952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11953     return 0;
11954   }
11955   arg2 = (Dali::Quaternion *)jarg2;
11956   if (!arg2) {
11957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11958     return 0;
11959   }
11960   arg3 = (float)jarg3;
11961   {
11962     try {
11963       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11964     } catch (std::out_of_range& e) {
11965       {
11966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11967       };
11968     } catch (std::exception& e) {
11969       {
11970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11971       };
11972     } catch (Dali::DaliException e) {
11973       {
11974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11975       };
11976     } catch (...) {
11977       {
11978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11979       };
11980     }
11981   }
11982
11983   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11984   return jresult;
11985 }
11986
11987
11988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
11989   void * jresult ;
11990   Dali::Quaternion *arg1 = 0 ;
11991   Dali::Quaternion *arg2 = 0 ;
11992   float arg3 ;
11993   Dali::Quaternion result;
11994
11995   arg1 = (Dali::Quaternion *)jarg1;
11996   if (!arg1) {
11997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11998     return 0;
11999   }
12000   arg2 = (Dali::Quaternion *)jarg2;
12001   if (!arg2) {
12002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12003     return 0;
12004   }
12005   arg3 = (float)jarg3;
12006   {
12007     try {
12008       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12009     } catch (std::out_of_range& e) {
12010       {
12011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12012       };
12013     } catch (std::exception& e) {
12014       {
12015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12016       };
12017     } catch (Dali::DaliException e) {
12018       {
12019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12020       };
12021     } catch (...) {
12022       {
12023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12024       };
12025     }
12026   }
12027
12028   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12029   return jresult;
12030 }
12031
12032
12033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12034   void * jresult ;
12035   Dali::Quaternion *arg1 = 0 ;
12036   Dali::Quaternion *arg2 = 0 ;
12037   Dali::Quaternion *arg3 = 0 ;
12038   Dali::Quaternion *arg4 = 0 ;
12039   float arg5 ;
12040   Dali::Quaternion result;
12041
12042   arg1 = (Dali::Quaternion *)jarg1;
12043   if (!arg1) {
12044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12045     return 0;
12046   }
12047   arg2 = (Dali::Quaternion *)jarg2;
12048   if (!arg2) {
12049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12050     return 0;
12051   }
12052   arg3 = (Dali::Quaternion *)jarg3;
12053   if (!arg3) {
12054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12055     return 0;
12056   }
12057   arg4 = (Dali::Quaternion *)jarg4;
12058   if (!arg4) {
12059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12060     return 0;
12061   }
12062   arg5 = (float)jarg5;
12063   {
12064     try {
12065       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12066     } catch (std::out_of_range& e) {
12067       {
12068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12069       };
12070     } catch (std::exception& e) {
12071       {
12072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12073       };
12074     } catch (Dali::DaliException e) {
12075       {
12076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12077       };
12078     } catch (...) {
12079       {
12080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12081       };
12082     }
12083   }
12084
12085   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12086   return jresult;
12087 }
12088
12089
12090 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12091   float jresult ;
12092   Dali::Quaternion *arg1 = 0 ;
12093   Dali::Quaternion *arg2 = 0 ;
12094   float result;
12095
12096   arg1 = (Dali::Quaternion *)jarg1;
12097   if (!arg1) {
12098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12099     return 0;
12100   }
12101   arg2 = (Dali::Quaternion *)jarg2;
12102   if (!arg2) {
12103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12104     return 0;
12105   }
12106   {
12107     try {
12108       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12109     } catch (std::out_of_range& e) {
12110       {
12111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12112       };
12113     } catch (std::exception& e) {
12114       {
12115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12116       };
12117     } catch (Dali::DaliException e) {
12118       {
12119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12120       };
12121     } catch (...) {
12122       {
12123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12124       };
12125     }
12126   }
12127
12128   jresult = result;
12129   return jresult;
12130 }
12131
12132
12133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12134   void * jresult ;
12135   Dali::Matrix *result = 0 ;
12136
12137   {
12138     try {
12139       result = (Dali::Matrix *)new Dali::Matrix();
12140     } catch (std::out_of_range& e) {
12141       {
12142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12143       };
12144     } catch (std::exception& e) {
12145       {
12146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12147       };
12148     } catch (Dali::DaliException e) {
12149       {
12150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12151       };
12152     } catch (...) {
12153       {
12154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12155       };
12156     }
12157   }
12158
12159   jresult = (void *)result;
12160   return jresult;
12161 }
12162
12163
12164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12165   void * jresult ;
12166   bool arg1 ;
12167   Dali::Matrix *result = 0 ;
12168
12169   arg1 = jarg1 ? true : false;
12170   {
12171     try {
12172       result = (Dali::Matrix *)new Dali::Matrix(arg1);
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_2(float* jarg1) {
12198   void * jresult ;
12199   float *arg1 = (float *) 0 ;
12200   Dali::Matrix *result = 0 ;
12201
12202   arg1 = jarg1;
12203   {
12204     try {
12205       result = (Dali::Matrix *)new Dali::Matrix((float const *)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
12227
12228   return jresult;
12229 }
12230
12231
12232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12233   void * jresult ;
12234   Dali::Quaternion *arg1 = 0 ;
12235   Dali::Matrix *result = 0 ;
12236
12237   arg1 = (Dali::Quaternion *)jarg1;
12238   if (!arg1) {
12239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12240     return 0;
12241   }
12242   {
12243     try {
12244       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12245     } catch (std::out_of_range& e) {
12246       {
12247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12248       };
12249     } catch (std::exception& e) {
12250       {
12251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12252       };
12253     } catch (Dali::DaliException e) {
12254       {
12255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12256       };
12257     } catch (...) {
12258       {
12259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12260       };
12261     }
12262   }
12263
12264   jresult = (void *)result;
12265   return jresult;
12266 }
12267
12268
12269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12270   void * jresult ;
12271   Dali::Matrix *arg1 = 0 ;
12272   Dali::Matrix *result = 0 ;
12273
12274   arg1 = (Dali::Matrix *)jarg1;
12275   if (!arg1) {
12276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12277     return 0;
12278   }
12279   {
12280     try {
12281       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12282     } catch (std::out_of_range& e) {
12283       {
12284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12285       };
12286     } catch (std::exception& e) {
12287       {
12288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12289       };
12290     } catch (Dali::DaliException e) {
12291       {
12292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12293       };
12294     } catch (...) {
12295       {
12296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12297       };
12298     }
12299   }
12300
12301   jresult = (void *)result;
12302   return jresult;
12303 }
12304
12305
12306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12307   void * jresult ;
12308   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12309   Dali::Matrix *arg2 = 0 ;
12310   Dali::Matrix *result = 0 ;
12311
12312   arg1 = (Dali::Matrix *)jarg1;
12313   arg2 = (Dali::Matrix *)jarg2;
12314   if (!arg2) {
12315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12316     return 0;
12317   }
12318   {
12319     try {
12320       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12321     } catch (std::out_of_range& e) {
12322       {
12323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12324       };
12325     } catch (std::exception& e) {
12326       {
12327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12328       };
12329     } catch (Dali::DaliException e) {
12330       {
12331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12332       };
12333     } catch (...) {
12334       {
12335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12336       };
12337     }
12338   }
12339
12340   jresult = (void *)result;
12341   return jresult;
12342 }
12343
12344
12345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12346   void * jresult ;
12347   Dali::Matrix *result = 0 ;
12348
12349   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12350   jresult = (void *)result;
12351   return jresult;
12352 }
12353
12354
12355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12356   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12357
12358   arg1 = (Dali::Matrix *)jarg1;
12359   {
12360     try {
12361       (arg1)->SetIdentity();
12362     } catch (std::out_of_range& e) {
12363       {
12364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12365       };
12366     } catch (std::exception& e) {
12367       {
12368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12369       };
12370     } catch (Dali::DaliException e) {
12371       {
12372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12373       };
12374     } catch (...) {
12375       {
12376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12377       };
12378     }
12379   }
12380
12381 }
12382
12383
12384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12385   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12386   Dali::Vector3 *arg2 = 0 ;
12387
12388   arg1 = (Dali::Matrix *)jarg1;
12389   arg2 = (Dali::Vector3 *)jarg2;
12390   if (!arg2) {
12391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12392     return ;
12393   }
12394   {
12395     try {
12396       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12397     } catch (std::out_of_range& e) {
12398       {
12399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12400       };
12401     } catch (std::exception& e) {
12402       {
12403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12404       };
12405     } catch (Dali::DaliException e) {
12406       {
12407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12408       };
12409     } catch (...) {
12410       {
12411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12412       };
12413     }
12414   }
12415
12416 }
12417
12418
12419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12420   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12421   Dali::Matrix *arg2 = 0 ;
12422
12423   arg1 = (Dali::Matrix *)jarg1;
12424   arg2 = (Dali::Matrix *)jarg2;
12425   if (!arg2) {
12426     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12427     return ;
12428   }
12429   {
12430     try {
12431       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12432     } catch (std::out_of_range& e) {
12433       {
12434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12435       };
12436     } catch (std::exception& e) {
12437       {
12438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12439       };
12440     } catch (Dali::DaliException e) {
12441       {
12442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12443       };
12444     } catch (...) {
12445       {
12446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12447       };
12448     }
12449   }
12450
12451 }
12452
12453
12454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12455   unsigned int jresult ;
12456   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12457   bool result;
12458
12459   arg1 = (Dali::Matrix *)jarg1;
12460   {
12461     try {
12462       result = (bool)(arg1)->Invert();
12463     } catch (std::out_of_range& e) {
12464       {
12465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12466       };
12467     } catch (std::exception& e) {
12468       {
12469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12470       };
12471     } catch (Dali::DaliException e) {
12472       {
12473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12474       };
12475     } catch (...) {
12476       {
12477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12478       };
12479     }
12480   }
12481
12482   jresult = result;
12483   return jresult;
12484 }
12485
12486
12487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12488   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12489
12490   arg1 = (Dali::Matrix *)jarg1;
12491   {
12492     try {
12493       (arg1)->Transpose();
12494     } catch (std::out_of_range& e) {
12495       {
12496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12497       };
12498     } catch (std::exception& e) {
12499       {
12500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12501       };
12502     } catch (Dali::DaliException e) {
12503       {
12504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12505       };
12506     } catch (...) {
12507       {
12508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12509       };
12510     }
12511   }
12512
12513 }
12514
12515
12516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12517   void * jresult ;
12518   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12519   Dali::Vector3 result;
12520
12521   arg1 = (Dali::Matrix *)jarg1;
12522   {
12523     try {
12524       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12525     } catch (std::out_of_range& e) {
12526       {
12527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12528       };
12529     } catch (std::exception& e) {
12530       {
12531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12532       };
12533     } catch (Dali::DaliException e) {
12534       {
12535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12536       };
12537     } catch (...) {
12538       {
12539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12540       };
12541     }
12542   }
12543
12544   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12545   return jresult;
12546 }
12547
12548
12549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(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)->GetYAxis();
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_GetZAxis(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)->GetZAxis();
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_SetXAxis(void * jarg1, void * jarg2) {
12616   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12617   Dali::Vector3 *arg2 = 0 ;
12618
12619   arg1 = (Dali::Matrix *)jarg1;
12620   arg2 = (Dali::Vector3 *)jarg2;
12621   if (!arg2) {
12622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12623     return ;
12624   }
12625   {
12626     try {
12627       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12628     } catch (std::out_of_range& e) {
12629       {
12630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12631       };
12632     } catch (std::exception& e) {
12633       {
12634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12635       };
12636     } catch (Dali::DaliException e) {
12637       {
12638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12639       };
12640     } catch (...) {
12641       {
12642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12643       };
12644     }
12645   }
12646
12647 }
12648
12649
12650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12651   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12652   Dali::Vector3 *arg2 = 0 ;
12653
12654   arg1 = (Dali::Matrix *)jarg1;
12655   arg2 = (Dali::Vector3 *)jarg2;
12656   if (!arg2) {
12657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12658     return ;
12659   }
12660   {
12661     try {
12662       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12663     } catch (std::out_of_range& e) {
12664       {
12665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12666       };
12667     } catch (std::exception& e) {
12668       {
12669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12670       };
12671     } catch (Dali::DaliException e) {
12672       {
12673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12674       };
12675     } catch (...) {
12676       {
12677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12678       };
12679     }
12680   }
12681
12682 }
12683
12684
12685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12686   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12687   Dali::Vector3 *arg2 = 0 ;
12688
12689   arg1 = (Dali::Matrix *)jarg1;
12690   arg2 = (Dali::Vector3 *)jarg2;
12691   if (!arg2) {
12692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12693     return ;
12694   }
12695   {
12696     try {
12697       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12698     } catch (std::out_of_range& e) {
12699       {
12700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12701       };
12702     } catch (std::exception& e) {
12703       {
12704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12705       };
12706     } catch (Dali::DaliException e) {
12707       {
12708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12709       };
12710     } catch (...) {
12711       {
12712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12713       };
12714     }
12715   }
12716
12717 }
12718
12719
12720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12721   void * jresult ;
12722   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12723   Dali::Vector4 *result = 0 ;
12724
12725   arg1 = (Dali::Matrix *)jarg1;
12726   {
12727     try {
12728       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12729     } catch (std::out_of_range& e) {
12730       {
12731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12732       };
12733     } catch (std::exception& e) {
12734       {
12735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12736       };
12737     } catch (Dali::DaliException e) {
12738       {
12739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12740       };
12741     } catch (...) {
12742       {
12743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12744       };
12745     }
12746   }
12747
12748   jresult = (void *)result;
12749   return jresult;
12750 }
12751
12752
12753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12754   void * jresult ;
12755   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12756   Dali::Vector3 *result = 0 ;
12757
12758   arg1 = (Dali::Matrix *)jarg1;
12759   {
12760     try {
12761       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
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_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12787   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12788   Dali::Vector4 *arg2 = 0 ;
12789
12790   arg1 = (Dali::Matrix *)jarg1;
12791   arg2 = (Dali::Vector4 *)jarg2;
12792   if (!arg2) {
12793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12794     return ;
12795   }
12796   {
12797     try {
12798       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12799     } catch (std::out_of_range& e) {
12800       {
12801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12802       };
12803     } catch (std::exception& e) {
12804       {
12805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12806       };
12807     } catch (Dali::DaliException e) {
12808       {
12809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12810       };
12811     } catch (...) {
12812       {
12813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12814       };
12815     }
12816   }
12817
12818 }
12819
12820
12821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12822   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12823   Dali::Vector3 *arg2 = 0 ;
12824
12825   arg1 = (Dali::Matrix *)jarg1;
12826   arg2 = (Dali::Vector3 *)jarg2;
12827   if (!arg2) {
12828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12829     return ;
12830   }
12831   {
12832     try {
12833       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12834     } catch (std::out_of_range& e) {
12835       {
12836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12837       };
12838     } catch (std::exception& e) {
12839       {
12840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12841       };
12842     } catch (Dali::DaliException e) {
12843       {
12844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12845       };
12846     } catch (...) {
12847       {
12848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12849       };
12850     }
12851   }
12852
12853 }
12854
12855
12856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12857   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12858
12859   arg1 = (Dali::Matrix *)jarg1;
12860   {
12861     try {
12862       (arg1)->OrthoNormalize();
12863     } catch (std::out_of_range& e) {
12864       {
12865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12866       };
12867     } catch (std::exception& e) {
12868       {
12869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12870       };
12871     } catch (Dali::DaliException e) {
12872       {
12873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12874       };
12875     } catch (...) {
12876       {
12877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12878       };
12879     }
12880   }
12881
12882 }
12883
12884
12885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12886   void * jresult ;
12887   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12888   float *result = 0 ;
12889
12890   arg1 = (Dali::Matrix *)jarg1;
12891   {
12892     try {
12893       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12894     } catch (std::out_of_range& e) {
12895       {
12896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12897       };
12898     } catch (std::exception& e) {
12899       {
12900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12901       };
12902     } catch (Dali::DaliException e) {
12903       {
12904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12905       };
12906     } catch (...) {
12907       {
12908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12909       };
12910     }
12911   }
12912
12913   jresult = (void *)result;
12914   return jresult;
12915 }
12916
12917
12918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12919   Dali::Matrix *arg1 = 0 ;
12920   Dali::Matrix *arg2 = 0 ;
12921   Dali::Matrix *arg3 = 0 ;
12922
12923   arg1 = (Dali::Matrix *)jarg1;
12924   if (!arg1) {
12925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12926     return ;
12927   }
12928   arg2 = (Dali::Matrix *)jarg2;
12929   if (!arg2) {
12930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12931     return ;
12932   }
12933   arg3 = (Dali::Matrix *)jarg3;
12934   if (!arg3) {
12935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12936     return ;
12937   }
12938   {
12939     try {
12940       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12941     } catch (std::out_of_range& e) {
12942       {
12943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12944       };
12945     } catch (std::exception& e) {
12946       {
12947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12948       };
12949     } catch (Dali::DaliException e) {
12950       {
12951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12952       };
12953     } catch (...) {
12954       {
12955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12956       };
12957     }
12958   }
12959
12960 }
12961
12962
12963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
12964   Dali::Matrix *arg1 = 0 ;
12965   Dali::Matrix *arg2 = 0 ;
12966   Dali::Quaternion *arg3 = 0 ;
12967
12968   arg1 = (Dali::Matrix *)jarg1;
12969   if (!arg1) {
12970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12971     return ;
12972   }
12973   arg2 = (Dali::Matrix *)jarg2;
12974   if (!arg2) {
12975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12976     return ;
12977   }
12978   arg3 = (Dali::Quaternion *)jarg3;
12979   if (!arg3) {
12980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12981     return ;
12982   }
12983   {
12984     try {
12985       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
12986     } catch (std::out_of_range& e) {
12987       {
12988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12989       };
12990     } catch (std::exception& e) {
12991       {
12992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12993       };
12994     } catch (Dali::DaliException e) {
12995       {
12996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12997       };
12998     } catch (...) {
12999       {
13000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13001       };
13002     }
13003   }
13004
13005 }
13006
13007
13008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13009   void * jresult ;
13010   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13011   Dali::Vector4 *arg2 = 0 ;
13012   Dali::Vector4 result;
13013
13014   arg1 = (Dali::Matrix *)jarg1;
13015   arg2 = (Dali::Vector4 *)jarg2;
13016   if (!arg2) {
13017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13018     return 0;
13019   }
13020   {
13021     try {
13022       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13023     } catch (std::out_of_range& e) {
13024       {
13025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13026       };
13027     } catch (std::exception& e) {
13028       {
13029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13030       };
13031     } catch (Dali::DaliException e) {
13032       {
13033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13034       };
13035     } catch (...) {
13036       {
13037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13038       };
13039     }
13040   }
13041
13042   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13043   return jresult;
13044 }
13045
13046
13047 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13048   unsigned int jresult ;
13049   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13050   Dali::Matrix *arg2 = 0 ;
13051   bool result;
13052
13053   arg1 = (Dali::Matrix *)jarg1;
13054   arg2 = (Dali::Matrix *)jarg2;
13055   if (!arg2) {
13056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13057     return 0;
13058   }
13059   {
13060     try {
13061       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13062     } catch (std::out_of_range& e) {
13063       {
13064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13065       };
13066     } catch (std::exception& e) {
13067       {
13068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13069       };
13070     } catch (Dali::DaliException e) {
13071       {
13072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13073       };
13074     } catch (...) {
13075       {
13076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13077       };
13078     }
13079   }
13080
13081   jresult = result;
13082   return jresult;
13083 }
13084
13085
13086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13087   unsigned int jresult ;
13088   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13089   Dali::Matrix *arg2 = 0 ;
13090   bool result;
13091
13092   arg1 = (Dali::Matrix *)jarg1;
13093   arg2 = (Dali::Matrix *)jarg2;
13094   if (!arg2) {
13095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13096     return 0;
13097   }
13098   {
13099     try {
13100       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13101     } catch (std::out_of_range& e) {
13102       {
13103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13104       };
13105     } catch (std::exception& e) {
13106       {
13107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13108       };
13109     } catch (Dali::DaliException e) {
13110       {
13111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13112       };
13113     } catch (...) {
13114       {
13115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13116       };
13117     }
13118   }
13119
13120   jresult = result;
13121   return jresult;
13122 }
13123
13124
13125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13126   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13127   Dali::Vector3 *arg2 = 0 ;
13128   Dali::Quaternion *arg3 = 0 ;
13129   Dali::Vector3 *arg4 = 0 ;
13130
13131   arg1 = (Dali::Matrix *)jarg1;
13132   arg2 = (Dali::Vector3 *)jarg2;
13133   if (!arg2) {
13134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13135     return ;
13136   }
13137   arg3 = (Dali::Quaternion *)jarg3;
13138   if (!arg3) {
13139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13140     return ;
13141   }
13142   arg4 = (Dali::Vector3 *)jarg4;
13143   if (!arg4) {
13144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13145     return ;
13146   }
13147   {
13148     try {
13149       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13150     } catch (std::out_of_range& e) {
13151       {
13152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13153       };
13154     } catch (std::exception& e) {
13155       {
13156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13157       };
13158     } catch (Dali::DaliException e) {
13159       {
13160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13161       };
13162     } catch (...) {
13163       {
13164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13165       };
13166     }
13167   }
13168
13169 }
13170
13171
13172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13173   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13174   Dali::Vector3 *arg2 = 0 ;
13175   Dali::Quaternion *arg3 = 0 ;
13176   Dali::Vector3 *arg4 = 0 ;
13177
13178   arg1 = (Dali::Matrix *)jarg1;
13179   arg2 = (Dali::Vector3 *)jarg2;
13180   if (!arg2) {
13181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13182     return ;
13183   }
13184   arg3 = (Dali::Quaternion *)jarg3;
13185   if (!arg3) {
13186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13187     return ;
13188   }
13189   arg4 = (Dali::Vector3 *)jarg4;
13190   if (!arg4) {
13191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13192     return ;
13193   }
13194   {
13195     try {
13196       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13197     } catch (std::out_of_range& e) {
13198       {
13199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13200       };
13201     } catch (std::exception& e) {
13202       {
13203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13204       };
13205     } catch (Dali::DaliException e) {
13206       {
13207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13208       };
13209     } catch (...) {
13210       {
13211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13212       };
13213     }
13214   }
13215
13216 }
13217
13218
13219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13220   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13221   Dali::Vector3 *arg2 = 0 ;
13222   Dali::Vector3 *arg3 = 0 ;
13223   Dali::Vector3 *arg4 = 0 ;
13224   Dali::Vector3 *arg5 = 0 ;
13225
13226   arg1 = (Dali::Matrix *)jarg1;
13227   arg2 = (Dali::Vector3 *)jarg2;
13228   if (!arg2) {
13229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13230     return ;
13231   }
13232   arg3 = (Dali::Vector3 *)jarg3;
13233   if (!arg3) {
13234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13235     return ;
13236   }
13237   arg4 = (Dali::Vector3 *)jarg4;
13238   if (!arg4) {
13239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13240     return ;
13241   }
13242   arg5 = (Dali::Vector3 *)jarg5;
13243   if (!arg5) {
13244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13245     return ;
13246   }
13247   {
13248     try {
13249       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13250     } catch (std::out_of_range& e) {
13251       {
13252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13253       };
13254     } catch (std::exception& e) {
13255       {
13256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13257       };
13258     } catch (Dali::DaliException e) {
13259       {
13260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13261       };
13262     } catch (...) {
13263       {
13264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13265       };
13266     }
13267   }
13268
13269 }
13270
13271
13272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13273   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13274   Dali::Vector3 *arg2 = 0 ;
13275   Dali::Quaternion *arg3 = 0 ;
13276   Dali::Vector3 *arg4 = 0 ;
13277
13278   arg1 = (Dali::Matrix *)jarg1;
13279   arg2 = (Dali::Vector3 *)jarg2;
13280   if (!arg2) {
13281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13282     return ;
13283   }
13284   arg3 = (Dali::Quaternion *)jarg3;
13285   if (!arg3) {
13286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13287     return ;
13288   }
13289   arg4 = (Dali::Vector3 *)jarg4;
13290   if (!arg4) {
13291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13292     return ;
13293   }
13294   {
13295     try {
13296       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13297     } catch (std::out_of_range& e) {
13298       {
13299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13300       };
13301     } catch (std::exception& e) {
13302       {
13303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13304       };
13305     } catch (Dali::DaliException e) {
13306       {
13307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13308       };
13309     } catch (...) {
13310       {
13311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13312       };
13313     }
13314   }
13315
13316 }
13317
13318
13319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13320   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13321
13322   arg1 = (Dali::Matrix *)jarg1;
13323   {
13324     try {
13325       delete arg1;
13326     } catch (std::out_of_range& e) {
13327       {
13328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13329       };
13330     } catch (std::exception& e) {
13331       {
13332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13333       };
13334     } catch (Dali::DaliException e) {
13335       {
13336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13337       };
13338     } catch (...) {
13339       {
13340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13341       };
13342     }
13343   }
13344
13345 }
13346
13347
13348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13349   void * jresult ;
13350   Dali::Matrix3 *result = 0 ;
13351
13352   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13353   jresult = (void *)result;
13354   return jresult;
13355 }
13356
13357
13358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13359   void * jresult ;
13360   Dali::Matrix3 *result = 0 ;
13361
13362   {
13363     try {
13364       result = (Dali::Matrix3 *)new Dali::Matrix3();
13365     } catch (std::out_of_range& e) {
13366       {
13367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13368       };
13369     } catch (std::exception& e) {
13370       {
13371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13372       };
13373     } catch (Dali::DaliException e) {
13374       {
13375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13376       };
13377     } catch (...) {
13378       {
13379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13380       };
13381     }
13382   }
13383
13384   jresult = (void *)result;
13385   return jresult;
13386 }
13387
13388
13389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13390   void * jresult ;
13391   Dali::Matrix3 *arg1 = 0 ;
13392   Dali::Matrix3 *result = 0 ;
13393
13394   arg1 = (Dali::Matrix3 *)jarg1;
13395   if (!arg1) {
13396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13397     return 0;
13398   }
13399   {
13400     try {
13401       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13402     } catch (std::out_of_range& e) {
13403       {
13404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13405       };
13406     } catch (std::exception& e) {
13407       {
13408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13409       };
13410     } catch (Dali::DaliException e) {
13411       {
13412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13413       };
13414     } catch (...) {
13415       {
13416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13417       };
13418     }
13419   }
13420
13421   jresult = (void *)result;
13422   return jresult;
13423 }
13424
13425
13426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13427   void * jresult ;
13428   Dali::Matrix *arg1 = 0 ;
13429   Dali::Matrix3 *result = 0 ;
13430
13431   arg1 = (Dali::Matrix *)jarg1;
13432   if (!arg1) {
13433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13434     return 0;
13435   }
13436   {
13437     try {
13438       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13439     } catch (std::out_of_range& e) {
13440       {
13441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13442       };
13443     } catch (std::exception& e) {
13444       {
13445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13446       };
13447     } catch (Dali::DaliException e) {
13448       {
13449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13450       };
13451     } catch (...) {
13452       {
13453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13454       };
13455     }
13456   }
13457
13458   jresult = (void *)result;
13459   return jresult;
13460 }
13461
13462
13463 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) {
13464   void * jresult ;
13465   float arg1 ;
13466   float arg2 ;
13467   float arg3 ;
13468   float arg4 ;
13469   float arg5 ;
13470   float arg6 ;
13471   float arg7 ;
13472   float arg8 ;
13473   float arg9 ;
13474   Dali::Matrix3 *result = 0 ;
13475
13476   arg1 = (float)jarg1;
13477   arg2 = (float)jarg2;
13478   arg3 = (float)jarg3;
13479   arg4 = (float)jarg4;
13480   arg5 = (float)jarg5;
13481   arg6 = (float)jarg6;
13482   arg7 = (float)jarg7;
13483   arg8 = (float)jarg8;
13484   arg9 = (float)jarg9;
13485   {
13486     try {
13487       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13488     } catch (std::out_of_range& e) {
13489       {
13490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13491       };
13492     } catch (std::exception& e) {
13493       {
13494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13495       };
13496     } catch (Dali::DaliException e) {
13497       {
13498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13499       };
13500     } catch (...) {
13501       {
13502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13503       };
13504     }
13505   }
13506
13507   jresult = (void *)result;
13508   return jresult;
13509 }
13510
13511
13512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13513   void * jresult ;
13514   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13515   Dali::Matrix3 *arg2 = 0 ;
13516   Dali::Matrix3 *result = 0 ;
13517
13518   arg1 = (Dali::Matrix3 *)jarg1;
13519   arg2 = (Dali::Matrix3 *)jarg2;
13520   if (!arg2) {
13521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13522     return 0;
13523   }
13524   {
13525     try {
13526       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13527     } catch (std::out_of_range& e) {
13528       {
13529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13530       };
13531     } catch (std::exception& e) {
13532       {
13533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13534       };
13535     } catch (Dali::DaliException e) {
13536       {
13537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13538       };
13539     } catch (...) {
13540       {
13541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13542       };
13543     }
13544   }
13545
13546   jresult = (void *)result;
13547   return jresult;
13548 }
13549
13550
13551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13552   void * jresult ;
13553   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13554   Dali::Matrix *arg2 = 0 ;
13555   Dali::Matrix3 *result = 0 ;
13556
13557   arg1 = (Dali::Matrix3 *)jarg1;
13558   arg2 = (Dali::Matrix *)jarg2;
13559   if (!arg2) {
13560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13561     return 0;
13562   }
13563   {
13564     try {
13565       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13566     } catch (std::out_of_range& e) {
13567       {
13568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13569       };
13570     } catch (std::exception& e) {
13571       {
13572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13573       };
13574     } catch (Dali::DaliException e) {
13575       {
13576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13577       };
13578     } catch (...) {
13579       {
13580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13581       };
13582     }
13583   }
13584
13585   jresult = (void *)result;
13586   return jresult;
13587 }
13588
13589
13590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13591   unsigned int jresult ;
13592   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13593   Dali::Matrix3 *arg2 = 0 ;
13594   bool result;
13595
13596   arg1 = (Dali::Matrix3 *)jarg1;
13597   arg2 = (Dali::Matrix3 *)jarg2;
13598   if (!arg2) {
13599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13600     return 0;
13601   }
13602   {
13603     try {
13604       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13605     } catch (std::out_of_range& e) {
13606       {
13607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13608       };
13609     } catch (std::exception& e) {
13610       {
13611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13612       };
13613     } catch (Dali::DaliException e) {
13614       {
13615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13616       };
13617     } catch (...) {
13618       {
13619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13620       };
13621     }
13622   }
13623
13624   jresult = result;
13625   return jresult;
13626 }
13627
13628
13629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13630   unsigned int jresult ;
13631   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13632   Dali::Matrix3 *arg2 = 0 ;
13633   bool result;
13634
13635   arg1 = (Dali::Matrix3 *)jarg1;
13636   arg2 = (Dali::Matrix3 *)jarg2;
13637   if (!arg2) {
13638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13639     return 0;
13640   }
13641   {
13642     try {
13643       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13644     } catch (std::out_of_range& e) {
13645       {
13646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13647       };
13648     } catch (std::exception& e) {
13649       {
13650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13651       };
13652     } catch (Dali::DaliException e) {
13653       {
13654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13655       };
13656     } catch (...) {
13657       {
13658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13659       };
13660     }
13661   }
13662
13663   jresult = result;
13664   return jresult;
13665 }
13666
13667
13668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13669   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13670
13671   arg1 = (Dali::Matrix3 *)jarg1;
13672   {
13673     try {
13674       delete arg1;
13675     } catch (std::out_of_range& e) {
13676       {
13677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13678       };
13679     } catch (std::exception& e) {
13680       {
13681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13682       };
13683     } catch (Dali::DaliException e) {
13684       {
13685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13686       };
13687     } catch (...) {
13688       {
13689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13690       };
13691     }
13692   }
13693
13694 }
13695
13696
13697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13698   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13699
13700   arg1 = (Dali::Matrix3 *)jarg1;
13701   {
13702     try {
13703       (arg1)->SetIdentity();
13704     } catch (std::out_of_range& e) {
13705       {
13706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13707       };
13708     } catch (std::exception& e) {
13709       {
13710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13711       };
13712     } catch (Dali::DaliException e) {
13713       {
13714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13715       };
13716     } catch (...) {
13717       {
13718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13719       };
13720     }
13721   }
13722
13723 }
13724
13725
13726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13727   void * jresult ;
13728   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13729   float *result = 0 ;
13730
13731   arg1 = (Dali::Matrix3 *)jarg1;
13732   {
13733     try {
13734       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13735     } catch (std::out_of_range& e) {
13736       {
13737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13738       };
13739     } catch (std::exception& e) {
13740       {
13741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13742       };
13743     } catch (Dali::DaliException e) {
13744       {
13745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13746       };
13747     } catch (...) {
13748       {
13749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13750       };
13751     }
13752   }
13753
13754   jresult = (void *)result;
13755   return jresult;
13756 }
13757
13758
13759 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13760   unsigned int jresult ;
13761   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13762   bool result;
13763
13764   arg1 = (Dali::Matrix3 *)jarg1;
13765   {
13766     try {
13767       result = (bool)(arg1)->Invert();
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 = result;
13788   return jresult;
13789 }
13790
13791
13792 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(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)->Transpose();
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 void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13826   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13827   float arg2 ;
13828
13829   arg1 = (Dali::Matrix3 *)jarg1;
13830   arg2 = (float)jarg2;
13831   {
13832     try {
13833       (arg1)->Scale(arg2);
13834     } catch (std::out_of_range& e) {
13835       {
13836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13837       };
13838     } catch (std::exception& e) {
13839       {
13840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13841       };
13842     } catch (Dali::DaliException e) {
13843       {
13844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13845       };
13846     } catch (...) {
13847       {
13848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13849       };
13850     }
13851   }
13852
13853 }
13854
13855
13856 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13857   float jresult ;
13858   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13859   float result;
13860
13861   arg1 = (Dali::Matrix3 *)jarg1;
13862   {
13863     try {
13864       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13865     } catch (std::out_of_range& e) {
13866       {
13867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13868       };
13869     } catch (std::exception& e) {
13870       {
13871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13872       };
13873     } catch (Dali::DaliException e) {
13874       {
13875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13876       };
13877     } catch (...) {
13878       {
13879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13880       };
13881     }
13882   }
13883
13884   jresult = result;
13885   return jresult;
13886 }
13887
13888
13889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13890   unsigned int jresult ;
13891   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13892   bool result;
13893
13894   arg1 = (Dali::Matrix3 *)jarg1;
13895   {
13896     try {
13897       result = (bool)(arg1)->ScaledInverseTranspose();
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 void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13923   Dali::Matrix3 *arg1 = 0 ;
13924   Dali::Matrix3 *arg2 = 0 ;
13925   Dali::Matrix3 *arg3 = 0 ;
13926
13927   arg1 = (Dali::Matrix3 *)jarg1;
13928   if (!arg1) {
13929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13930     return ;
13931   }
13932   arg2 = (Dali::Matrix3 *)jarg2;
13933   if (!arg2) {
13934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13935     return ;
13936   }
13937   arg3 = (Dali::Matrix3 *)jarg3;
13938   if (!arg3) {
13939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13940     return ;
13941   }
13942   {
13943     try {
13944       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13945     } catch (std::out_of_range& e) {
13946       {
13947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13948       };
13949     } catch (std::exception& e) {
13950       {
13951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13952       };
13953     } catch (Dali::DaliException e) {
13954       {
13955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13956       };
13957     } catch (...) {
13958       {
13959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13960       };
13961     }
13962   }
13963
13964 }
13965
13966
13967 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
13968   float jresult ;
13969   float arg1 ;
13970   float arg2 ;
13971   float result;
13972
13973   arg1 = (float)jarg1;
13974   arg2 = (float)jarg2;
13975   {
13976     try {
13977       result = (float)Dali::Random::Range(arg1,arg2);
13978     } catch (std::out_of_range& e) {
13979       {
13980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13981       };
13982     } catch (std::exception& e) {
13983       {
13984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13985       };
13986     } catch (Dali::DaliException e) {
13987       {
13988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13989       };
13990     } catch (...) {
13991       {
13992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13993       };
13994     }
13995   }
13996
13997   jresult = result;
13998   return jresult;
13999 }
14000
14001
14002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14003   void * jresult ;
14004   Dali::Vector4 result;
14005
14006   {
14007     try {
14008       result = Dali::Random::Axis();
14009     } catch (std::out_of_range& e) {
14010       {
14011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14012       };
14013     } catch (std::exception& e) {
14014       {
14015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14016       };
14017     } catch (Dali::DaliException e) {
14018       {
14019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14020       };
14021     } catch (...) {
14022       {
14023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14024       };
14025     }
14026   }
14027
14028   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14029   return jresult;
14030 }
14031
14032
14033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14034   void * jresult ;
14035   Dali::AngleAxis *result = 0 ;
14036
14037   {
14038     try {
14039       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14040     } catch (std::out_of_range& e) {
14041       {
14042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14043       };
14044     } catch (std::exception& e) {
14045       {
14046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14047       };
14048     } catch (Dali::DaliException e) {
14049       {
14050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14051       };
14052     } catch (...) {
14053       {
14054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14055       };
14056     }
14057   }
14058
14059   jresult = (void *)result;
14060   return jresult;
14061 }
14062
14063
14064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14065   void * jresult ;
14066   Dali::Radian arg1 ;
14067   Dali::Vector3 *arg2 = 0 ;
14068   Dali::Radian *argp1 ;
14069   Dali::AngleAxis *result = 0 ;
14070
14071   argp1 = (Dali::Radian *)jarg1;
14072   if (!argp1) {
14073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14074     return 0;
14075   }
14076   arg1 = *argp1;
14077   arg2 = (Dali::Vector3 *)jarg2;
14078   if (!arg2) {
14079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14080     return 0;
14081   }
14082   {
14083     try {
14084       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14085     } catch (std::out_of_range& e) {
14086       {
14087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14088       };
14089     } catch (std::exception& e) {
14090       {
14091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14092       };
14093     } catch (Dali::DaliException e) {
14094       {
14095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14096       };
14097     } catch (...) {
14098       {
14099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14100       };
14101     }
14102   }
14103
14104   jresult = (void *)result;
14105   return jresult;
14106 }
14107
14108
14109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14110   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14111   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14112
14113   arg1 = (Dali::AngleAxis *)jarg1;
14114   arg2 = (Dali::Radian *)jarg2;
14115   if (arg1) (arg1)->angle = *arg2;
14116 }
14117
14118
14119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14120   void * jresult ;
14121   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14122   Dali::Radian *result = 0 ;
14123
14124   arg1 = (Dali::AngleAxis *)jarg1;
14125   result = (Dali::Radian *)& ((arg1)->angle);
14126   jresult = (void *)result;
14127   return jresult;
14128 }
14129
14130
14131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14132   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14133   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14134
14135   arg1 = (Dali::AngleAxis *)jarg1;
14136   arg2 = (Dali::Vector3 *)jarg2;
14137   if (arg1) (arg1)->axis = *arg2;
14138 }
14139
14140
14141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14142   void * jresult ;
14143   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14144   Dali::Vector3 *result = 0 ;
14145
14146   arg1 = (Dali::AngleAxis *)jarg1;
14147   result = (Dali::Vector3 *)& ((arg1)->axis);
14148   jresult = (void *)result;
14149   return jresult;
14150 }
14151
14152
14153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14154   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14155
14156   arg1 = (Dali::AngleAxis *)jarg1;
14157   {
14158     try {
14159       delete arg1;
14160     } catch (std::out_of_range& e) {
14161       {
14162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14163       };
14164     } catch (std::exception& e) {
14165       {
14166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14167       };
14168     } catch (Dali::DaliException e) {
14169       {
14170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14171       };
14172     } catch (...) {
14173       {
14174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14175       };
14176     }
14177   }
14178
14179 }
14180
14181
14182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14183   unsigned int jresult ;
14184   Dali::AngleAxis *arg1 = 0 ;
14185   Dali::AngleAxis *arg2 = 0 ;
14186   bool result;
14187
14188   arg1 = (Dali::AngleAxis *)jarg1;
14189   if (!arg1) {
14190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14191     return 0;
14192   }
14193   arg2 = (Dali::AngleAxis *)jarg2;
14194   if (!arg2) {
14195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14196     return 0;
14197   }
14198   {
14199     try {
14200       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14201     } catch (std::out_of_range& e) {
14202       {
14203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14204       };
14205     } catch (std::exception& e) {
14206       {
14207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14208       };
14209     } catch (Dali::DaliException e) {
14210       {
14211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14212       };
14213     } catch (...) {
14214       {
14215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14216       };
14217     }
14218   }
14219
14220   jresult = result;
14221   return jresult;
14222 }
14223
14224
14225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14226   unsigned int jresult ;
14227   unsigned int arg1 ;
14228   unsigned int result;
14229
14230   arg1 = (unsigned int)jarg1;
14231   {
14232     try {
14233       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
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_IsPowerOfTwo(unsigned int jarg1) {
14259   unsigned int jresult ;
14260   unsigned int arg1 ;
14261   bool result;
14262
14263   arg1 = (unsigned int)jarg1;
14264   {
14265     try {
14266       result = (bool)Dali::IsPowerOfTwo(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 float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14292   float jresult ;
14293   float arg1 ;
14294   float arg2 ;
14295   float result;
14296
14297   arg1 = (float)jarg1;
14298   arg2 = (float)jarg2;
14299   {
14300     try {
14301       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14302     } catch (std::out_of_range& e) {
14303       {
14304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14305       };
14306     } catch (std::exception& e) {
14307       {
14308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14309       };
14310     } catch (Dali::DaliException e) {
14311       {
14312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14313       };
14314     } catch (...) {
14315       {
14316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14317       };
14318     }
14319   }
14320
14321   jresult = result;
14322   return jresult;
14323 }
14324
14325
14326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14327   unsigned int jresult ;
14328   float arg1 ;
14329   bool result;
14330
14331   arg1 = (float)jarg1;
14332   {
14333     try {
14334       result = (bool)Dali::EqualsZero(arg1);
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_Equals__SWIG_0(float jarg1, float jarg2) {
14360   unsigned int jresult ;
14361   float arg1 ;
14362   float arg2 ;
14363   bool result;
14364
14365   arg1 = (float)jarg1;
14366   arg2 = (float)jarg2;
14367   {
14368     try {
14369       result = (bool)Dali::Equals(arg1,arg2);
14370     } catch (std::out_of_range& e) {
14371       {
14372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14373       };
14374     } catch (std::exception& e) {
14375       {
14376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14377       };
14378     } catch (Dali::DaliException e) {
14379       {
14380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14381       };
14382     } catch (...) {
14383       {
14384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14385       };
14386     }
14387   }
14388
14389   jresult = result;
14390   return jresult;
14391 }
14392
14393
14394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14395   unsigned int jresult ;
14396   float arg1 ;
14397   float arg2 ;
14398   float arg3 ;
14399   bool result;
14400
14401   arg1 = (float)jarg1;
14402   arg2 = (float)jarg2;
14403   arg3 = (float)jarg3;
14404   {
14405     try {
14406       result = (bool)Dali::Equals(arg1,arg2,arg3);
14407     } catch (std::out_of_range& e) {
14408       {
14409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14410       };
14411     } catch (std::exception& e) {
14412       {
14413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14414       };
14415     } catch (Dali::DaliException e) {
14416       {
14417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14418       };
14419     } catch (...) {
14420       {
14421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14422       };
14423     }
14424   }
14425
14426   jresult = result;
14427   return jresult;
14428 }
14429
14430
14431 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14432   float jresult ;
14433   float arg1 ;
14434   int arg2 ;
14435   float result;
14436
14437   arg1 = (float)jarg1;
14438   arg2 = (int)jarg2;
14439   {
14440     try {
14441       result = (float)Dali::Round(arg1,arg2);
14442     } catch (std::out_of_range& e) {
14443       {
14444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14445       };
14446     } catch (std::exception& e) {
14447       {
14448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14449       };
14450     } catch (Dali::DaliException e) {
14451       {
14452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14453       };
14454     } catch (...) {
14455       {
14456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14457       };
14458     }
14459   }
14460
14461   jresult = result;
14462   return jresult;
14463 }
14464
14465
14466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14467   float jresult ;
14468   float arg1 ;
14469   float arg2 ;
14470   float arg3 ;
14471   float result;
14472
14473   arg1 = (float)jarg1;
14474   arg2 = (float)jarg2;
14475   arg3 = (float)jarg3;
14476   {
14477     try {
14478       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14479     } catch (std::out_of_range& e) {
14480       {
14481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14482       };
14483     } catch (std::exception& e) {
14484       {
14485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14486       };
14487     } catch (Dali::DaliException e) {
14488       {
14489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14490       };
14491     } catch (...) {
14492       {
14493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14494       };
14495     }
14496   }
14497
14498   jresult = result;
14499   return jresult;
14500 }
14501
14502
14503 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14504   float jresult ;
14505   float arg1 ;
14506   float arg2 ;
14507   float arg3 ;
14508   float arg4 ;
14509   float result;
14510
14511   arg1 = (float)jarg1;
14512   arg2 = (float)jarg2;
14513   arg3 = (float)jarg3;
14514   arg4 = (float)jarg4;
14515   {
14516     try {
14517       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14518     } catch (std::out_of_range& e) {
14519       {
14520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14521       };
14522     } catch (std::exception& e) {
14523       {
14524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14525       };
14526     } catch (Dali::DaliException e) {
14527       {
14528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14529       };
14530     } catch (...) {
14531       {
14532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14533       };
14534     }
14535   }
14536
14537   jresult = result;
14538   return jresult;
14539 }
14540
14541
14542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14543   int jresult ;
14544   int result;
14545
14546   result = (int)(int)Dali::Property::INVALID_INDEX;
14547   jresult = result;
14548   return jresult;
14549 }
14550
14551
14552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14553   int jresult ;
14554   int result;
14555
14556   result = (int)(int)Dali::Property::INVALID_KEY;
14557   jresult = result;
14558   return jresult;
14559 }
14560
14561
14562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14563   int jresult ;
14564   int result;
14565
14566   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14567   jresult = result;
14568   return jresult;
14569 }
14570
14571
14572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14573   void * jresult ;
14574   Dali::Handle *arg1 = 0 ;
14575   Dali::Property::Index arg2 ;
14576   Dali::Property *result = 0 ;
14577
14578   arg1 = (Dali::Handle *)jarg1;
14579   if (!arg1) {
14580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14581     return 0;
14582   }
14583   arg2 = (Dali::Property::Index)jarg2;
14584   {
14585     try {
14586       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14587     } catch (std::out_of_range& e) {
14588       {
14589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14590       };
14591     } catch (std::exception& e) {
14592       {
14593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14594       };
14595     } catch (Dali::DaliException e) {
14596       {
14597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14598       };
14599     } catch (...) {
14600       {
14601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14602       };
14603     }
14604   }
14605
14606   jresult = (void *)result;
14607   return jresult;
14608 }
14609
14610
14611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14612   void * jresult ;
14613   Dali::Handle *arg1 = 0 ;
14614   Dali::Property::Index arg2 ;
14615   int arg3 ;
14616   Dali::Property *result = 0 ;
14617
14618   arg1 = (Dali::Handle *)jarg1;
14619   if (!arg1) {
14620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14621     return 0;
14622   }
14623   arg2 = (Dali::Property::Index)jarg2;
14624   arg3 = (int)jarg3;
14625   {
14626     try {
14627       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14628     } catch (std::out_of_range& e) {
14629       {
14630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14631       };
14632     } catch (std::exception& e) {
14633       {
14634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14635       };
14636     } catch (Dali::DaliException e) {
14637       {
14638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14639       };
14640     } catch (...) {
14641       {
14642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14643       };
14644     }
14645   }
14646
14647   jresult = (void *)result;
14648   return jresult;
14649 }
14650
14651
14652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14653   void * jresult ;
14654   Dali::Handle *arg1 = 0 ;
14655   std::string *arg2 = 0 ;
14656   Dali::Property *result = 0 ;
14657
14658   arg1 = (Dali::Handle *)jarg1;
14659   if (!arg1) {
14660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14661     return 0;
14662   }
14663   if (!jarg2) {
14664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14665     return 0;
14666   }
14667   std::string arg2_str(jarg2);
14668   arg2 = &arg2_str;
14669   {
14670     try {
14671       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14672     } catch (std::out_of_range& e) {
14673       {
14674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14675       };
14676     } catch (std::exception& e) {
14677       {
14678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14679       };
14680     } catch (Dali::DaliException e) {
14681       {
14682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14683       };
14684     } catch (...) {
14685       {
14686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14687       };
14688     }
14689   }
14690
14691   jresult = (void *)result;
14692
14693   //argout typemap for const std::string&
14694
14695   return jresult;
14696 }
14697
14698
14699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14700   void * jresult ;
14701   Dali::Handle *arg1 = 0 ;
14702   std::string *arg2 = 0 ;
14703   int arg3 ;
14704   Dali::Property *result = 0 ;
14705
14706   arg1 = (Dali::Handle *)jarg1;
14707   if (!arg1) {
14708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14709     return 0;
14710   }
14711   if (!jarg2) {
14712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14713     return 0;
14714   }
14715   std::string arg2_str(jarg2);
14716   arg2 = &arg2_str;
14717   arg3 = (int)jarg3;
14718   {
14719     try {
14720       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14721     } catch (std::out_of_range& e) {
14722       {
14723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14724       };
14725     } catch (std::exception& e) {
14726       {
14727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14728       };
14729     } catch (Dali::DaliException e) {
14730       {
14731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14732       };
14733     } catch (...) {
14734       {
14735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14736       };
14737     }
14738   }
14739
14740   jresult = (void *)result;
14741
14742   //argout typemap for const std::string&
14743
14744   return jresult;
14745 }
14746
14747
14748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14749   Dali::Property *arg1 = (Dali::Property *) 0 ;
14750
14751   arg1 = (Dali::Property *)jarg1;
14752   {
14753     try {
14754       delete arg1;
14755     } catch (std::out_of_range& e) {
14756       {
14757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14758       };
14759     } catch (std::exception& e) {
14760       {
14761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14762       };
14763     } catch (Dali::DaliException e) {
14764       {
14765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14766       };
14767     } catch (...) {
14768       {
14769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14770       };
14771     }
14772   }
14773
14774 }
14775
14776
14777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14778   Dali::Property *arg1 = (Dali::Property *) 0 ;
14779   Dali::Handle *arg2 = 0 ;
14780
14781   arg1 = (Dali::Property *)jarg1;
14782   arg2 = (Dali::Handle *)jarg2;
14783   if (!arg2) {
14784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14785     return ;
14786   }
14787   if (arg1) (arg1)->object = *arg2;
14788 }
14789
14790
14791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14792   void * jresult ;
14793   Dali::Property *arg1 = (Dali::Property *) 0 ;
14794   Dali::Handle *result = 0 ;
14795
14796   arg1 = (Dali::Property *)jarg1;
14797   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14798   jresult = (void *)result;
14799   return jresult;
14800 }
14801
14802
14803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14804   Dali::Property *arg1 = (Dali::Property *) 0 ;
14805   Dali::Property::Index arg2 ;
14806
14807   arg1 = (Dali::Property *)jarg1;
14808   arg2 = (Dali::Property::Index)jarg2;
14809   if (arg1) (arg1)->propertyIndex = arg2;
14810 }
14811
14812
14813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14814   int jresult ;
14815   Dali::Property *arg1 = (Dali::Property *) 0 ;
14816   Dali::Property::Index result;
14817
14818   arg1 = (Dali::Property *)jarg1;
14819   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14820   jresult = result;
14821   return jresult;
14822 }
14823
14824
14825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14826   Dali::Property *arg1 = (Dali::Property *) 0 ;
14827   int arg2 ;
14828
14829   arg1 = (Dali::Property *)jarg1;
14830   arg2 = (int)jarg2;
14831   if (arg1) (arg1)->componentIndex = arg2;
14832 }
14833
14834
14835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14836   int jresult ;
14837   Dali::Property *arg1 = (Dali::Property *) 0 ;
14838   int result;
14839
14840   arg1 = (Dali::Property *)jarg1;
14841   result = (int) ((arg1)->componentIndex);
14842   jresult = result;
14843   return jresult;
14844 }
14845
14846
14847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14848   void * jresult ;
14849   Dali::Property::Array *result = 0 ;
14850
14851   {
14852     try {
14853       result = (Dali::Property::Array *)new Dali::Property::Array();
14854     } catch (std::out_of_range& e) {
14855       {
14856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14857       };
14858     } catch (std::exception& e) {
14859       {
14860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14861       };
14862     } catch (Dali::DaliException e) {
14863       {
14864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14865       };
14866     } catch (...) {
14867       {
14868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14869       };
14870     }
14871   }
14872
14873   jresult = (void *)result;
14874   return jresult;
14875 }
14876
14877
14878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14879   void * jresult ;
14880   Dali::Property::Array *arg1 = 0 ;
14881   Dali::Property::Array *result = 0 ;
14882
14883   arg1 = (Dali::Property::Array *)jarg1;
14884   if (!arg1) {
14885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14886     return 0;
14887   }
14888   {
14889     try {
14890       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14891     } catch (std::out_of_range& e) {
14892       {
14893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14894       };
14895     } catch (std::exception& e) {
14896       {
14897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14898       };
14899     } catch (Dali::DaliException e) {
14900       {
14901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14902       };
14903     } catch (...) {
14904       {
14905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14906       };
14907     }
14908   }
14909
14910   jresult = (void *)result;
14911   return jresult;
14912 }
14913
14914
14915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14916   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14917
14918   arg1 = (Dali::Property::Array *)jarg1;
14919   {
14920     try {
14921       delete arg1;
14922     } catch (std::out_of_range& e) {
14923       {
14924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14925       };
14926     } catch (std::exception& e) {
14927       {
14928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14929       };
14930     } catch (Dali::DaliException e) {
14931       {
14932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14933       };
14934     } catch (...) {
14935       {
14936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14937       };
14938     }
14939   }
14940
14941 }
14942
14943
14944 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14945   unsigned long jresult ;
14946   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14947   Dali::Property::Array::SizeType result;
14948
14949   arg1 = (Dali::Property::Array *)jarg1;
14950   {
14951     try {
14952       result = ((Dali::Property::Array const *)arg1)->Size();
14953     } catch (std::out_of_range& e) {
14954       {
14955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14956       };
14957     } catch (std::exception& e) {
14958       {
14959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14960       };
14961     } catch (Dali::DaliException e) {
14962       {
14963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14964       };
14965     } catch (...) {
14966       {
14967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14968       };
14969     }
14970   }
14971
14972   jresult = (unsigned long)result;
14973   return jresult;
14974 }
14975
14976
14977 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(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)->Count();
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 int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15011   unsigned int jresult ;
15012   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15013   bool result;
15014
15015   arg1 = (Dali::Property::Array *)jarg1;
15016   {
15017     try {
15018       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
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 = result;
15039   return jresult;
15040 }
15041
15042
15043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15044   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15045
15046   arg1 = (Dali::Property::Array *)jarg1;
15047   {
15048     try {
15049       (arg1)->Clear();
15050     } catch (std::out_of_range& e) {
15051       {
15052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15053       };
15054     } catch (std::exception& e) {
15055       {
15056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15057       };
15058     } catch (Dali::DaliException e) {
15059       {
15060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15061       };
15062     } catch (...) {
15063       {
15064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15065       };
15066     }
15067   }
15068
15069 }
15070
15071
15072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15073   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15074   Dali::Property::Array::SizeType arg2 ;
15075
15076   arg1 = (Dali::Property::Array *)jarg1;
15077   arg2 = (Dali::Property::Array::SizeType)jarg2;
15078   {
15079     try {
15080       (arg1)->Reserve(arg2);
15081     } catch (std::out_of_range& e) {
15082       {
15083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15084       };
15085     } catch (std::exception& e) {
15086       {
15087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15088       };
15089     } catch (Dali::DaliException e) {
15090       {
15091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15092       };
15093     } catch (...) {
15094       {
15095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15096       };
15097     }
15098   }
15099
15100 }
15101
15102
15103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15104   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15105   Dali::Property::Array::SizeType arg2 ;
15106
15107   arg1 = (Dali::Property::Array *)jarg1;
15108   arg2 = (Dali::Property::Array::SizeType)jarg2;
15109   {
15110     try {
15111       (arg1)->Resize(arg2);
15112     } catch (std::out_of_range& e) {
15113       {
15114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15115       };
15116     } catch (std::exception& e) {
15117       {
15118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15119       };
15120     } catch (Dali::DaliException e) {
15121       {
15122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15123       };
15124     } catch (...) {
15125       {
15126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15127       };
15128     }
15129   }
15130
15131 }
15132
15133
15134 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15135   unsigned long jresult ;
15136   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15137   Dali::Property::Array::SizeType result;
15138
15139   arg1 = (Dali::Property::Array *)jarg1;
15140   {
15141     try {
15142       result = (arg1)->Capacity();
15143     } catch (std::out_of_range& e) {
15144       {
15145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15146       };
15147     } catch (std::exception& e) {
15148       {
15149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15150       };
15151     } catch (Dali::DaliException e) {
15152       {
15153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15154       };
15155     } catch (...) {
15156       {
15157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15158       };
15159     }
15160   }
15161
15162   jresult = (unsigned long)result;
15163   return jresult;
15164 }
15165
15166
15167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15168   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15169   Dali::Property::Value *arg2 = 0 ;
15170
15171   arg1 = (Dali::Property::Array *)jarg1;
15172   arg2 = (Dali::Property::Value *)jarg2;
15173   if (!arg2) {
15174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15175     return ;
15176   }
15177   {
15178     try {
15179       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15180     } catch (std::out_of_range& e) {
15181       {
15182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15183       };
15184     } catch (std::exception& e) {
15185       {
15186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15187       };
15188     } catch (Dali::DaliException e) {
15189       {
15190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15191       };
15192     } catch (...) {
15193       {
15194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15195       };
15196     }
15197   }
15198
15199 }
15200
15201
15202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15203   void * jresult ;
15204   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15205   Dali::Property::Value *arg2 = 0 ;
15206   Dali::Property::Array *result = 0 ;
15207
15208   arg1 = (Dali::Property::Array *)jarg1;
15209   arg2 = (Dali::Property::Value *)jarg2;
15210   if (!arg2) {
15211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15212     return 0;
15213   }
15214   {
15215     try {
15216       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15217     } catch (std::out_of_range& e) {
15218       {
15219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15220       };
15221     } catch (std::exception& e) {
15222       {
15223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15224       };
15225     } catch (Dali::DaliException e) {
15226       {
15227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15228       };
15229     } catch (...) {
15230       {
15231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15232       };
15233     }
15234   }
15235
15236   jresult = (void *)result;
15237   return jresult;
15238 }
15239
15240
15241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15242   void * jresult ;
15243   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15244   Dali::Property::Array::SizeType arg2 ;
15245   Dali::Property::Value *result = 0 ;
15246
15247   arg1 = (Dali::Property::Array *)jarg1;
15248   arg2 = (Dali::Property::Array::SizeType)jarg2;
15249   {
15250     try {
15251       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15252     } catch (std::out_of_range& e) {
15253       {
15254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15255       };
15256     } catch (std::exception& e) {
15257       {
15258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15259       };
15260     } catch (Dali::DaliException e) {
15261       {
15262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15263       };
15264     } catch (...) {
15265       {
15266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15267       };
15268     }
15269   }
15270
15271   jresult = (void *)result;
15272   return jresult;
15273 }
15274
15275
15276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15277   void * jresult ;
15278   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15279   Dali::Property::Array::SizeType arg2 ;
15280   Dali::Property::Value *result = 0 ;
15281
15282   arg1 = (Dali::Property::Array *)jarg1;
15283   arg2 = (Dali::Property::Array::SizeType)jarg2;
15284   {
15285     try {
15286       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15287     } catch (std::out_of_range& e) {
15288       {
15289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15290       };
15291     } catch (std::exception& e) {
15292       {
15293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15294       };
15295     } catch (Dali::DaliException e) {
15296       {
15297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15298       };
15299     } catch (...) {
15300       {
15301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15302       };
15303     }
15304   }
15305
15306   jresult = (void *)result;
15307   return jresult;
15308 }
15309
15310
15311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15312   void * jresult ;
15313   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15314   Dali::Property::Array *arg2 = 0 ;
15315   Dali::Property::Array *result = 0 ;
15316
15317   arg1 = (Dali::Property::Array *)jarg1;
15318   arg2 = (Dali::Property::Array *)jarg2;
15319   if (!arg2) {
15320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15321     return 0;
15322   }
15323   {
15324     try {
15325       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15326     } catch (std::out_of_range& e) {
15327       {
15328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15329       };
15330     } catch (std::exception& e) {
15331       {
15332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15333       };
15334     } catch (Dali::DaliException e) {
15335       {
15336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15337       };
15338     } catch (...) {
15339       {
15340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15341       };
15342     }
15343   }
15344
15345   jresult = (void *)result;
15346   return jresult;
15347 }
15348
15349
15350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15351   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15352   enum Dali::Property::Key::Type arg2 ;
15353
15354   arg1 = (Dali::Property::Key *)jarg1;
15355   arg2 = (enum Dali::Property::Key::Type)jarg2;
15356   if (arg1) (arg1)->type = arg2;
15357 }
15358
15359
15360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15361   int jresult ;
15362   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15363   enum Dali::Property::Key::Type result;
15364
15365   arg1 = (Dali::Property::Key *)jarg1;
15366   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15367   jresult = (int)result;
15368   return jresult;
15369 }
15370
15371
15372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15373   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15374   Dali::Property::Index arg2 ;
15375
15376   arg1 = (Dali::Property::Key *)jarg1;
15377   arg2 = (Dali::Property::Index)jarg2;
15378   if (arg1) (arg1)->indexKey = arg2;
15379 }
15380
15381
15382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15383   int jresult ;
15384   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15385   Dali::Property::Index result;
15386
15387   arg1 = (Dali::Property::Key *)jarg1;
15388   result = (Dali::Property::Index) ((arg1)->indexKey);
15389   jresult = result;
15390   return jresult;
15391 }
15392
15393
15394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15395   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15396   std::string *arg2 = 0 ;
15397
15398   arg1 = (Dali::Property::Key *)jarg1;
15399   if (!jarg2) {
15400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15401     return ;
15402   }
15403   std::string arg2_str(jarg2);
15404   arg2 = &arg2_str;
15405   if (arg1) (arg1)->stringKey = *arg2;
15406
15407   //argout typemap for const std::string&
15408
15409 }
15410
15411
15412 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15413   char * jresult ;
15414   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15415   std::string *result = 0 ;
15416
15417   arg1 = (Dali::Property::Key *)jarg1;
15418   result = (std::string *) & ((arg1)->stringKey);
15419   jresult = SWIG_csharp_string_callback(result->c_str());
15420   return jresult;
15421 }
15422
15423
15424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15425   void * jresult ;
15426   std::string *arg1 = 0 ;
15427   Dali::Property::Key *result = 0 ;
15428
15429   if (!jarg1) {
15430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15431     return 0;
15432   }
15433   std::string arg1_str(jarg1);
15434   arg1 = &arg1_str;
15435   {
15436     try {
15437       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15438     } catch (std::out_of_range& e) {
15439       {
15440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15441       };
15442     } catch (std::exception& e) {
15443       {
15444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15445       };
15446     } catch (Dali::DaliException e) {
15447       {
15448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15449       };
15450     } catch (...) {
15451       {
15452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15453       };
15454     }
15455   }
15456
15457   jresult = (void *)result;
15458
15459   //argout typemap for const std::string&
15460
15461   return jresult;
15462 }
15463
15464
15465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15466   void * jresult ;
15467   Dali::Property::Index arg1 ;
15468   Dali::Property::Key *result = 0 ;
15469
15470   arg1 = (Dali::Property::Index)jarg1;
15471   {
15472     try {
15473       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15474     } catch (std::out_of_range& e) {
15475       {
15476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15477       };
15478     } catch (std::exception& e) {
15479       {
15480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15481       };
15482     } catch (Dali::DaliException e) {
15483       {
15484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15485       };
15486     } catch (...) {
15487       {
15488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15489       };
15490     }
15491   }
15492
15493   jresult = (void *)result;
15494   return jresult;
15495 }
15496
15497
15498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15499   unsigned int jresult ;
15500   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15501   std::string *arg2 = 0 ;
15502   bool result;
15503
15504   arg1 = (Dali::Property::Key *)jarg1;
15505   if (!jarg2) {
15506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15507     return 0;
15508   }
15509   std::string arg2_str(jarg2);
15510   arg2 = &arg2_str;
15511   {
15512     try {
15513       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15514     } catch (std::out_of_range& e) {
15515       {
15516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15517       };
15518     } catch (std::exception& e) {
15519       {
15520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15521       };
15522     } catch (Dali::DaliException e) {
15523       {
15524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15525       };
15526     } catch (...) {
15527       {
15528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15529       };
15530     }
15531   }
15532
15533   jresult = result;
15534
15535   //argout typemap for const std::string&
15536
15537   return jresult;
15538 }
15539
15540
15541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15542   unsigned int jresult ;
15543   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15544   Dali::Property::Index arg2 ;
15545   bool result;
15546
15547   arg1 = (Dali::Property::Key *)jarg1;
15548   arg2 = (Dali::Property::Index)jarg2;
15549   {
15550     try {
15551       result = (bool)(arg1)->operator ==(arg2);
15552     } catch (std::out_of_range& e) {
15553       {
15554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15555       };
15556     } catch (std::exception& e) {
15557       {
15558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15559       };
15560     } catch (Dali::DaliException e) {
15561       {
15562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15563       };
15564     } catch (...) {
15565       {
15566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15567       };
15568     }
15569   }
15570
15571   jresult = result;
15572   return jresult;
15573 }
15574
15575
15576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15577   unsigned int jresult ;
15578   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15579   Dali::Property::Key *arg2 = 0 ;
15580   bool result;
15581
15582   arg1 = (Dali::Property::Key *)jarg1;
15583   arg2 = (Dali::Property::Key *)jarg2;
15584   if (!arg2) {
15585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15586     return 0;
15587   }
15588   {
15589     try {
15590       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15591     } catch (std::out_of_range& e) {
15592       {
15593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15594       };
15595     } catch (std::exception& e) {
15596       {
15597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15598       };
15599     } catch (Dali::DaliException e) {
15600       {
15601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15602       };
15603     } catch (...) {
15604       {
15605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15606       };
15607     }
15608   }
15609
15610   jresult = result;
15611   return jresult;
15612 }
15613
15614
15615 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15616   unsigned int jresult ;
15617   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15618   std::string *arg2 = 0 ;
15619   bool result;
15620
15621   arg1 = (Dali::Property::Key *)jarg1;
15622   if (!jarg2) {
15623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15624     return 0;
15625   }
15626   std::string arg2_str(jarg2);
15627   arg2 = &arg2_str;
15628   {
15629     try {
15630       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15631     } catch (std::out_of_range& e) {
15632       {
15633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15634       };
15635     } catch (std::exception& e) {
15636       {
15637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15638       };
15639     } catch (Dali::DaliException e) {
15640       {
15641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15642       };
15643     } catch (...) {
15644       {
15645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15646       };
15647     }
15648   }
15649
15650   jresult = result;
15651
15652   //argout typemap for const std::string&
15653
15654   return jresult;
15655 }
15656
15657
15658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15659   unsigned int jresult ;
15660   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15661   Dali::Property::Index arg2 ;
15662   bool result;
15663
15664   arg1 = (Dali::Property::Key *)jarg1;
15665   arg2 = (Dali::Property::Index)jarg2;
15666   {
15667     try {
15668       result = (bool)(arg1)->operator !=(arg2);
15669     } catch (std::out_of_range& e) {
15670       {
15671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15672       };
15673     } catch (std::exception& e) {
15674       {
15675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15676       };
15677     } catch (Dali::DaliException e) {
15678       {
15679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15680       };
15681     } catch (...) {
15682       {
15683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15684       };
15685     }
15686   }
15687
15688   jresult = result;
15689   return jresult;
15690 }
15691
15692
15693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15694   unsigned int jresult ;
15695   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15696   Dali::Property::Key *arg2 = 0 ;
15697   bool result;
15698
15699   arg1 = (Dali::Property::Key *)jarg1;
15700   arg2 = (Dali::Property::Key *)jarg2;
15701   if (!arg2) {
15702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15703     return 0;
15704   }
15705   {
15706     try {
15707       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15708     } catch (std::out_of_range& e) {
15709       {
15710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15711       };
15712     } catch (std::exception& e) {
15713       {
15714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15715       };
15716     } catch (Dali::DaliException e) {
15717       {
15718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15719       };
15720     } catch (...) {
15721       {
15722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15723       };
15724     }
15725   }
15726
15727   jresult = result;
15728   return jresult;
15729 }
15730
15731
15732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15733   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15734
15735   arg1 = (Dali::Property::Key *)jarg1;
15736   {
15737     try {
15738       delete arg1;
15739     } catch (std::out_of_range& e) {
15740       {
15741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15742       };
15743     } catch (std::exception& e) {
15744       {
15745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15746       };
15747     } catch (Dali::DaliException e) {
15748       {
15749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15750       };
15751     } catch (...) {
15752       {
15753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15754       };
15755     }
15756   }
15757
15758 }
15759
15760
15761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15762   void * jresult ;
15763   Dali::Property::Map *result = 0 ;
15764
15765   {
15766     try {
15767       result = (Dali::Property::Map *)new Dali::Property::Map();
15768     } catch (std::out_of_range& e) {
15769       {
15770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15771       };
15772     } catch (std::exception& e) {
15773       {
15774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15775       };
15776     } catch (Dali::DaliException e) {
15777       {
15778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15779       };
15780     } catch (...) {
15781       {
15782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15783       };
15784     }
15785   }
15786
15787   jresult = (void *)result;
15788   return jresult;
15789 }
15790
15791
15792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15793   void * jresult ;
15794   Dali::Property::Map *arg1 = 0 ;
15795   Dali::Property::Map *result = 0 ;
15796
15797   arg1 = (Dali::Property::Map *)jarg1;
15798   if (!arg1) {
15799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15800     return 0;
15801   }
15802   {
15803     try {
15804       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15805     } catch (std::out_of_range& e) {
15806       {
15807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15808       };
15809     } catch (std::exception& e) {
15810       {
15811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15812       };
15813     } catch (Dali::DaliException e) {
15814       {
15815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15816       };
15817     } catch (...) {
15818       {
15819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15820       };
15821     }
15822   }
15823
15824   jresult = (void *)result;
15825   return jresult;
15826 }
15827
15828
15829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15830   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15831
15832   arg1 = (Dali::Property::Map *)jarg1;
15833   {
15834     try {
15835       delete arg1;
15836     } catch (std::out_of_range& e) {
15837       {
15838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15839       };
15840     } catch (std::exception& e) {
15841       {
15842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15843       };
15844     } catch (Dali::DaliException e) {
15845       {
15846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15847       };
15848     } catch (...) {
15849       {
15850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15851       };
15852     }
15853   }
15854
15855 }
15856
15857
15858 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15859   unsigned long jresult ;
15860   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15861   Dali::Property::Map::SizeType result;
15862
15863   arg1 = (Dali::Property::Map *)jarg1;
15864   {
15865     try {
15866       result = ((Dali::Property::Map const *)arg1)->Count();
15867     } catch (std::out_of_range& e) {
15868       {
15869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15870       };
15871     } catch (std::exception& e) {
15872       {
15873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15874       };
15875     } catch (Dali::DaliException e) {
15876       {
15877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15878       };
15879     } catch (...) {
15880       {
15881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15882       };
15883     }
15884   }
15885
15886   jresult = (unsigned long)result;
15887   return jresult;
15888 }
15889
15890
15891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15892   unsigned int jresult ;
15893   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15894   bool result;
15895
15896   arg1 = (Dali::Property::Map *)jarg1;
15897   {
15898     try {
15899       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
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 = result;
15920   return jresult;
15921 }
15922
15923
15924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15925   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15926   char *arg2 = (char *) 0 ;
15927   Dali::Property::Value *arg3 = 0 ;
15928
15929   arg1 = (Dali::Property::Map *)jarg1;
15930   arg2 = (char *)jarg2;
15931   arg3 = (Dali::Property::Value *)jarg3;
15932   if (!arg3) {
15933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15934     return ;
15935   }
15936   {
15937     try {
15938       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15939     } catch (std::out_of_range& e) {
15940       {
15941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15942       };
15943     } catch (std::exception& e) {
15944       {
15945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15946       };
15947     } catch (Dali::DaliException e) {
15948       {
15949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15950       };
15951     } catch (...) {
15952       {
15953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15954       };
15955     }
15956   }
15957
15958 }
15959
15960
15961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15962   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15963   Dali::Property::Index arg2 ;
15964   Dali::Property::Value *arg3 = 0 ;
15965
15966   arg1 = (Dali::Property::Map *)jarg1;
15967   arg2 = (Dali::Property::Index)jarg2;
15968   arg3 = (Dali::Property::Value *)jarg3;
15969   if (!arg3) {
15970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15971     return ;
15972   }
15973   {
15974     try {
15975       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
15976     } catch (std::out_of_range& e) {
15977       {
15978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15979       };
15980     } catch (std::exception& e) {
15981       {
15982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15983       };
15984     } catch (Dali::DaliException e) {
15985       {
15986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15987       };
15988     } catch (...) {
15989       {
15990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15991       };
15992     }
15993   }
15994
15995 }
15996
15997
15998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15999   void * jresult ;
16000   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16001   char *arg2 = (char *) 0 ;
16002   Dali::Property::Value *arg3 = 0 ;
16003   Dali::Property::Map *result = 0 ;
16004
16005   arg1 = (Dali::Property::Map *)jarg1;
16006   arg2 = (char *)jarg2;
16007   arg3 = (Dali::Property::Value *)jarg3;
16008   if (!arg3) {
16009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16010     return 0;
16011   }
16012   {
16013     try {
16014       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16015     } catch (std::out_of_range& e) {
16016       {
16017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16018       };
16019     } catch (std::exception& e) {
16020       {
16021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16022       };
16023     } catch (Dali::DaliException e) {
16024       {
16025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16026       };
16027     } catch (...) {
16028       {
16029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16030       };
16031     }
16032   }
16033
16034   jresult = (void *)result;
16035   return jresult;
16036 }
16037
16038
16039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16040   void * jresult ;
16041   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16042   Dali::Property::Index arg2 ;
16043   Dali::Property::Value *arg3 = 0 ;
16044   Dali::Property::Map *result = 0 ;
16045
16046   arg1 = (Dali::Property::Map *)jarg1;
16047   arg2 = (Dali::Property::Index)jarg2;
16048   arg3 = (Dali::Property::Value *)jarg3;
16049   if (!arg3) {
16050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16051     return 0;
16052   }
16053   {
16054     try {
16055       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16056     } catch (std::out_of_range& e) {
16057       {
16058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16059       };
16060     } catch (std::exception& e) {
16061       {
16062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16063       };
16064     } catch (Dali::DaliException e) {
16065       {
16066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16067       };
16068     } catch (...) {
16069       {
16070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16071       };
16072     }
16073   }
16074
16075   jresult = (void *)result;
16076   return jresult;
16077 }
16078
16079
16080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16081   void * jresult ;
16082   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16083   Dali::Property::Map::SizeType arg2 ;
16084   Dali::Property::Value *result = 0 ;
16085
16086   arg1 = (Dali::Property::Map *)jarg1;
16087   arg2 = (Dali::Property::Map::SizeType)jarg2;
16088   {
16089     try {
16090       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16091     } catch (std::out_of_range& e) {
16092       {
16093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16094       };
16095     } catch (std::exception& e) {
16096       {
16097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16098       };
16099     } catch (Dali::DaliException e) {
16100       {
16101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16102       };
16103     } catch (...) {
16104       {
16105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16106       };
16107     }
16108   }
16109
16110   jresult = (void *)result;
16111   return jresult;
16112 }
16113
16114
16115 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16116   char * jresult ;
16117   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16118   Dali::Property::Map::SizeType arg2 ;
16119   std::string *result = 0 ;
16120
16121   arg1 = (Dali::Property::Map *)jarg1;
16122   arg2 = (Dali::Property::Map::SizeType)jarg2;
16123   {
16124     try {
16125       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16126     } catch (std::out_of_range& e) {
16127       {
16128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16129       };
16130     } catch (std::exception& e) {
16131       {
16132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16133       };
16134     } catch (Dali::DaliException e) {
16135       {
16136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16137       };
16138     } catch (...) {
16139       {
16140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16141       };
16142     }
16143   }
16144
16145   jresult = SWIG_csharp_string_callback(result->c_str());
16146   return jresult;
16147 }
16148
16149
16150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16151   void * jresult ;
16152   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16153   Dali::Property::Map::SizeType arg2 ;
16154   SwigValueWrapper< Dali::Property::Key > result;
16155
16156   arg1 = (Dali::Property::Map *)jarg1;
16157   arg2 = (Dali::Property::Map::SizeType)jarg2;
16158   {
16159     try {
16160       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16161     } catch (std::out_of_range& e) {
16162       {
16163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16164       };
16165     } catch (std::exception& e) {
16166       {
16167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16168       };
16169     } catch (Dali::DaliException e) {
16170       {
16171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16172       };
16173     } catch (...) {
16174       {
16175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16176       };
16177     }
16178   }
16179
16180   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16181   return jresult;
16182 }
16183
16184
16185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16186   void * jresult ;
16187   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16188   Dali::Property::Map::SizeType arg2 ;
16189   StringValuePair *result = 0 ;
16190
16191   arg1 = (Dali::Property::Map *)jarg1;
16192   arg2 = (Dali::Property::Map::SizeType)jarg2;
16193   {
16194     try {
16195       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16196     } catch (std::out_of_range& e) {
16197       {
16198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16199       };
16200     } catch (std::exception& e) {
16201       {
16202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16203       };
16204     } catch (Dali::DaliException e) {
16205       {
16206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16207       };
16208     } catch (...) {
16209       {
16210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16211       };
16212     }
16213   }
16214
16215   jresult = (void *)result;
16216   return jresult;
16217 }
16218
16219
16220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16221   void * jresult ;
16222   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16223   char *arg2 = (char *) 0 ;
16224   Dali::Property::Value *result = 0 ;
16225
16226   arg1 = (Dali::Property::Map *)jarg1;
16227   arg2 = (char *)jarg2;
16228   {
16229     try {
16230       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16231     } catch (std::out_of_range& e) {
16232       {
16233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16234       };
16235     } catch (std::exception& e) {
16236       {
16237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16238       };
16239     } catch (Dali::DaliException e) {
16240       {
16241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16242       };
16243     } catch (...) {
16244       {
16245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16246       };
16247     }
16248   }
16249
16250   jresult = (void *)result;
16251   return jresult;
16252 }
16253
16254
16255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16256   void * jresult ;
16257   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16258   Dali::Property::Index arg2 ;
16259   Dali::Property::Value *result = 0 ;
16260
16261   arg1 = (Dali::Property::Map *)jarg1;
16262   arg2 = (Dali::Property::Index)jarg2;
16263   {
16264     try {
16265       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16266     } catch (std::out_of_range& e) {
16267       {
16268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16269       };
16270     } catch (std::exception& e) {
16271       {
16272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16273       };
16274     } catch (Dali::DaliException e) {
16275       {
16276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16277       };
16278     } catch (...) {
16279       {
16280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16281       };
16282     }
16283   }
16284
16285   jresult = (void *)result;
16286   return jresult;
16287 }
16288
16289
16290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16291   void * jresult ;
16292   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16293   Dali::Property::Index arg2 ;
16294   std::string *arg3 = 0 ;
16295   Dali::Property::Value *result = 0 ;
16296
16297   arg1 = (Dali::Property::Map *)jarg1;
16298   arg2 = (Dali::Property::Index)jarg2;
16299   if (!jarg3) {
16300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16301     return 0;
16302   }
16303   std::string arg3_str(jarg3);
16304   arg3 = &arg3_str;
16305   {
16306     try {
16307       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16308     } catch (std::out_of_range& e) {
16309       {
16310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16311       };
16312     } catch (std::exception& e) {
16313       {
16314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16315       };
16316     } catch (Dali::DaliException e) {
16317       {
16318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16319       };
16320     } catch (...) {
16321       {
16322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16323       };
16324     }
16325   }
16326
16327   jresult = (void *)result;
16328
16329   //argout typemap for const std::string&
16330
16331   return jresult;
16332 }
16333
16334
16335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16336   void * jresult ;
16337   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16338   std::string *arg2 = 0 ;
16339   Dali::Property::Type arg3 ;
16340   Dali::Property::Value *result = 0 ;
16341
16342   arg1 = (Dali::Property::Map *)jarg1;
16343   if (!jarg2) {
16344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16345     return 0;
16346   }
16347   std::string arg2_str(jarg2);
16348   arg2 = &arg2_str;
16349   arg3 = (Dali::Property::Type)jarg3;
16350   {
16351     try {
16352       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16353     } catch (std::out_of_range& e) {
16354       {
16355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16356       };
16357     } catch (std::exception& e) {
16358       {
16359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16360       };
16361     } catch (Dali::DaliException e) {
16362       {
16363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16364       };
16365     } catch (...) {
16366       {
16367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16368       };
16369     }
16370   }
16371
16372   jresult = (void *)result;
16373
16374   //argout typemap for const std::string&
16375
16376   return jresult;
16377 }
16378
16379
16380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16381   void * jresult ;
16382   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16383   Dali::Property::Index arg2 ;
16384   Dali::Property::Type arg3 ;
16385   Dali::Property::Value *result = 0 ;
16386
16387   arg1 = (Dali::Property::Map *)jarg1;
16388   arg2 = (Dali::Property::Index)jarg2;
16389   arg3 = (Dali::Property::Type)jarg3;
16390   {
16391     try {
16392       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16393     } catch (std::out_of_range& e) {
16394       {
16395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16396       };
16397     } catch (std::exception& e) {
16398       {
16399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16400       };
16401     } catch (Dali::DaliException e) {
16402       {
16403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16404       };
16405     } catch (...) {
16406       {
16407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16408       };
16409     }
16410   }
16411
16412   jresult = (void *)result;
16413   return jresult;
16414 }
16415
16416
16417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16418   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16419
16420   arg1 = (Dali::Property::Map *)jarg1;
16421   {
16422     try {
16423       (arg1)->Clear();
16424     } catch (std::out_of_range& e) {
16425       {
16426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16427       };
16428     } catch (std::exception& e) {
16429       {
16430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16431       };
16432     } catch (Dali::DaliException e) {
16433       {
16434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16435       };
16436     } catch (...) {
16437       {
16438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16439       };
16440     }
16441   }
16442
16443 }
16444
16445
16446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16447   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16448   Dali::Property::Map *arg2 = 0 ;
16449
16450   arg1 = (Dali::Property::Map *)jarg1;
16451   arg2 = (Dali::Property::Map *)jarg2;
16452   if (!arg2) {
16453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16454     return ;
16455   }
16456   {
16457     try {
16458       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16459     } catch (std::out_of_range& e) {
16460       {
16461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16462       };
16463     } catch (std::exception& e) {
16464       {
16465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16466       };
16467     } catch (Dali::DaliException e) {
16468       {
16469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16470       };
16471     } catch (...) {
16472       {
16473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16474       };
16475     }
16476   }
16477
16478 }
16479
16480
16481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16482   void * jresult ;
16483   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16484   std::string *arg2 = 0 ;
16485   Dali::Property::Value *result = 0 ;
16486
16487   arg1 = (Dali::Property::Map *)jarg1;
16488   if (!jarg2) {
16489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16490     return 0;
16491   }
16492   std::string arg2_str(jarg2);
16493   arg2 = &arg2_str;
16494   {
16495     try {
16496       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16497     } catch (std::out_of_range& e) {
16498       {
16499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16500       };
16501     } catch (std::exception& e) {
16502       {
16503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16504       };
16505     } catch (Dali::DaliException e) {
16506       {
16507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16508       };
16509     } catch (...) {
16510       {
16511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16512       };
16513     }
16514   }
16515
16516   jresult = (void *)result;
16517
16518   //argout typemap for const std::string&
16519
16520   return jresult;
16521 }
16522
16523
16524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16525   void * jresult ;
16526   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16527   Dali::Property::Index arg2 ;
16528   Dali::Property::Value *result = 0 ;
16529
16530   arg1 = (Dali::Property::Map *)jarg1;
16531   arg2 = (Dali::Property::Index)jarg2;
16532   {
16533     try {
16534       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16535     } catch (std::out_of_range& e) {
16536       {
16537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16538       };
16539     } catch (std::exception& e) {
16540       {
16541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16542       };
16543     } catch (Dali::DaliException e) {
16544       {
16545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16546       };
16547     } catch (...) {
16548       {
16549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16550       };
16551     }
16552   }
16553
16554   jresult = (void *)result;
16555   return jresult;
16556 }
16557
16558
16559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16560   void * jresult ;
16561   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16562   Dali::Property::Map *arg2 = 0 ;
16563   Dali::Property::Map *result = 0 ;
16564
16565   arg1 = (Dali::Property::Map *)jarg1;
16566   arg2 = (Dali::Property::Map *)jarg2;
16567   if (!arg2) {
16568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16569     return 0;
16570   }
16571   {
16572     try {
16573       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16574     } catch (std::out_of_range& e) {
16575       {
16576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16577       };
16578     } catch (std::exception& e) {
16579       {
16580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16581       };
16582     } catch (Dali::DaliException e) {
16583       {
16584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16585       };
16586     } catch (...) {
16587       {
16588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16589       };
16590     }
16591   }
16592
16593   jresult = (void *)result;
16594   return jresult;
16595 }
16596
16597
16598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
16599
16600   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16601
16602   if (!jarg2) {
16603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16604     return;
16605   }
16606   std::string arg2_str(jarg2);
16607   std::string* arg2 = &arg2_str;
16608
16609   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16610
16611   {
16612     try {
16613       arg1->operator[]((std::string const &)*arg2) = *arg3;
16614     } catch (std::out_of_range& e) {
16615       {
16616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16617       };
16618     } catch (std::exception& e) {
16619       {
16620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16621       };
16622     } catch (Dali::DaliException e) {
16623       {
16624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16625       };
16626     } catch (...) {
16627       {
16628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16629       };
16630     }
16631   }
16632 }
16633
16634
16635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
16636
16637   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16638   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
16639   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16640
16641   {
16642     try {
16643       arg1->operator[](arg2) = *arg3;
16644     } catch (std::out_of_range& e) {
16645       {
16646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16647       };
16648     } catch (std::exception& e) {
16649       {
16650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16651       };
16652     } catch (Dali::DaliException e) {
16653       {
16654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16655       };
16656     } catch (...) {
16657       {
16658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16659       };
16660     }
16661   }
16662 }
16663
16664
16665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16666   void * jresult ;
16667   Dali::Property::Value *result = 0 ;
16668
16669   {
16670     try {
16671       result = (Dali::Property::Value *)new Dali::Property::Value();
16672     } catch (std::out_of_range& e) {
16673       {
16674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16675       };
16676     } catch (std::exception& e) {
16677       {
16678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16679       };
16680     } catch (Dali::DaliException e) {
16681       {
16682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16683       };
16684     } catch (...) {
16685       {
16686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16687       };
16688     }
16689   }
16690
16691   jresult = (void *)result;
16692   return jresult;
16693 }
16694
16695
16696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16697   void * jresult ;
16698   bool arg1 ;
16699   Dali::Property::Value *result = 0 ;
16700
16701   arg1 = jarg1 ? true : false;
16702   {
16703     try {
16704       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
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_2(int jarg1) {
16730   void * jresult ;
16731   int arg1 ;
16732   Dali::Property::Value *result = 0 ;
16733
16734   arg1 = (int)jarg1;
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_3(float jarg1) {
16763   void * jresult ;
16764   float arg1 ;
16765   Dali::Property::Value *result = 0 ;
16766
16767   arg1 = (float)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_4(void * jarg1) {
16796   void * jresult ;
16797   Dali::Vector2 *arg1 = 0 ;
16798   Dali::Property::Value *result = 0 ;
16799
16800   arg1 = (Dali::Vector2 *)jarg1;
16801   if (!arg1) {
16802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16803     return 0;
16804   }
16805   {
16806     try {
16807       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16808     } catch (std::out_of_range& e) {
16809       {
16810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16811       };
16812     } catch (std::exception& e) {
16813       {
16814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16815       };
16816     } catch (Dali::DaliException e) {
16817       {
16818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16819       };
16820     } catch (...) {
16821       {
16822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16823       };
16824     }
16825   }
16826
16827   jresult = (void *)result;
16828   return jresult;
16829 }
16830
16831
16832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16833   void * jresult ;
16834   Dali::Vector3 *arg1 = 0 ;
16835   Dali::Property::Value *result = 0 ;
16836
16837   arg1 = (Dali::Vector3 *)jarg1;
16838   if (!arg1) {
16839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16840     return 0;
16841   }
16842   {
16843     try {
16844       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16845     } catch (std::out_of_range& e) {
16846       {
16847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16848       };
16849     } catch (std::exception& e) {
16850       {
16851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16852       };
16853     } catch (Dali::DaliException e) {
16854       {
16855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16856       };
16857     } catch (...) {
16858       {
16859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16860       };
16861     }
16862   }
16863
16864   jresult = (void *)result;
16865   return jresult;
16866 }
16867
16868
16869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16870   void * jresult ;
16871   Dali::Vector4 *arg1 = 0 ;
16872   Dali::Property::Value *result = 0 ;
16873
16874   arg1 = (Dali::Vector4 *)jarg1;
16875   if (!arg1) {
16876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16877     return 0;
16878   }
16879   {
16880     try {
16881       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16882     } catch (std::out_of_range& e) {
16883       {
16884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16885       };
16886     } catch (std::exception& e) {
16887       {
16888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16889       };
16890     } catch (Dali::DaliException e) {
16891       {
16892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16893       };
16894     } catch (...) {
16895       {
16896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16897       };
16898     }
16899   }
16900
16901   jresult = (void *)result;
16902   return jresult;
16903 }
16904
16905
16906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16907   void * jresult ;
16908   Dali::Matrix3 *arg1 = 0 ;
16909   Dali::Property::Value *result = 0 ;
16910
16911   arg1 = (Dali::Matrix3 *)jarg1;
16912   if (!arg1) {
16913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16914     return 0;
16915   }
16916   {
16917     try {
16918       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16919     } catch (std::out_of_range& e) {
16920       {
16921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16922       };
16923     } catch (std::exception& e) {
16924       {
16925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16926       };
16927     } catch (Dali::DaliException e) {
16928       {
16929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16930       };
16931     } catch (...) {
16932       {
16933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16934       };
16935     }
16936   }
16937
16938   jresult = (void *)result;
16939   return jresult;
16940 }
16941
16942
16943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16944   void * jresult ;
16945   Dali::Matrix *arg1 = 0 ;
16946   Dali::Property::Value *result = 0 ;
16947
16948   arg1 = (Dali::Matrix *)jarg1;
16949   if (!arg1) {
16950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16951     return 0;
16952   }
16953   {
16954     try {
16955       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16956     } catch (std::out_of_range& e) {
16957       {
16958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16959       };
16960     } catch (std::exception& e) {
16961       {
16962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16963       };
16964     } catch (Dali::DaliException e) {
16965       {
16966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16967       };
16968     } catch (...) {
16969       {
16970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16971       };
16972     }
16973   }
16974
16975   jresult = (void *)result;
16976   return jresult;
16977 }
16978
16979
16980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16981   void * jresult ;
16982   Dali::Rect< int > *arg1 = 0 ;
16983   Dali::Property::Value *result = 0 ;
16984
16985   arg1 = (Dali::Rect< int > *)jarg1;
16986   if (!arg1) {
16987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16988     return 0;
16989   }
16990   {
16991     try {
16992       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16993     } catch (std::out_of_range& e) {
16994       {
16995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16996       };
16997     } catch (std::exception& e) {
16998       {
16999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17000       };
17001     } catch (Dali::DaliException e) {
17002       {
17003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17004       };
17005     } catch (...) {
17006       {
17007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17008       };
17009     }
17010   }
17011
17012   jresult = (void *)result;
17013   return jresult;
17014 }
17015
17016
17017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17018   void * jresult ;
17019   Dali::AngleAxis *arg1 = 0 ;
17020   Dali::Property::Value *result = 0 ;
17021
17022   arg1 = (Dali::AngleAxis *)jarg1;
17023   if (!arg1) {
17024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17025     return 0;
17026   }
17027   {
17028     try {
17029       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17030     } catch (std::out_of_range& e) {
17031       {
17032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17033       };
17034     } catch (std::exception& e) {
17035       {
17036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17037       };
17038     } catch (Dali::DaliException e) {
17039       {
17040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17041       };
17042     } catch (...) {
17043       {
17044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17045       };
17046     }
17047   }
17048
17049   jresult = (void *)result;
17050   return jresult;
17051 }
17052
17053
17054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17055   void * jresult ;
17056   Dali::Quaternion *arg1 = 0 ;
17057   Dali::Property::Value *result = 0 ;
17058
17059   arg1 = (Dali::Quaternion *)jarg1;
17060   if (!arg1) {
17061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17062     return 0;
17063   }
17064   {
17065     try {
17066       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17067     } catch (std::out_of_range& e) {
17068       {
17069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17070       };
17071     } catch (std::exception& e) {
17072       {
17073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17074       };
17075     } catch (Dali::DaliException e) {
17076       {
17077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17078       };
17079     } catch (...) {
17080       {
17081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17082       };
17083     }
17084   }
17085
17086   jresult = (void *)result;
17087   return jresult;
17088 }
17089
17090
17091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17092   void * jresult ;
17093   std::string *arg1 = 0 ;
17094   Dali::Property::Value *result = 0 ;
17095
17096   if (!jarg1) {
17097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17098     return 0;
17099   }
17100   std::string arg1_str(jarg1);
17101   arg1 = &arg1_str;
17102   {
17103     try {
17104       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17105     } catch (std::out_of_range& e) {
17106       {
17107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17108       };
17109     } catch (std::exception& e) {
17110       {
17111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17112       };
17113     } catch (Dali::DaliException e) {
17114       {
17115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17116       };
17117     } catch (...) {
17118       {
17119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17120       };
17121     }
17122   }
17123
17124   jresult = (void *)result;
17125
17126   //argout typemap for const std::string&
17127
17128   return jresult;
17129 }
17130
17131
17132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17133   void * jresult ;
17134   Dali::Property::Array *arg1 = 0 ;
17135   Dali::Property::Value *result = 0 ;
17136
17137   arg1 = (Dali::Property::Array *)jarg1;
17138   if (!arg1) {
17139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17140     return 0;
17141   }
17142   {
17143     try {
17144       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17145     } catch (std::out_of_range& e) {
17146       {
17147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17148       };
17149     } catch (std::exception& e) {
17150       {
17151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17152       };
17153     } catch (Dali::DaliException e) {
17154       {
17155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17156       };
17157     } catch (...) {
17158       {
17159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17160       };
17161     }
17162   }
17163
17164   jresult = (void *)result;
17165   return jresult;
17166 }
17167
17168
17169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17170   void * jresult ;
17171   Dali::Property::Map *arg1 = 0 ;
17172   Dali::Property::Value *result = 0 ;
17173
17174   arg1 = (Dali::Property::Map *)jarg1;
17175   if (!arg1) {
17176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17177     return 0;
17178   }
17179   {
17180     try {
17181       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17182     } catch (std::out_of_range& e) {
17183       {
17184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17185       };
17186     } catch (std::exception& e) {
17187       {
17188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17189       };
17190     } catch (Dali::DaliException e) {
17191       {
17192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17193       };
17194     } catch (...) {
17195       {
17196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17197       };
17198     }
17199   }
17200
17201   jresult = (void *)result;
17202   return jresult;
17203 }
17204
17205
17206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17207   void * jresult ;
17208   Extents *arg1 = 0 ;
17209   Dali::Property::Value *result = 0 ;
17210
17211   arg1 = (Extents *)jarg1;
17212   if (!arg1) {
17213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17214     return 0;
17215   }
17216   {
17217     try {
17218       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17219     } catch (std::out_of_range& e) {
17220       {
17221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17222       };
17223     } catch (std::exception& e) {
17224       {
17225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17226       };
17227     } catch (...) {
17228       {
17229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17230       };
17231     }
17232   }
17233   jresult = (void *)result;
17234   return jresult;
17235 }
17236
17237
17238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17239   void * jresult ;
17240   Dali::Property::Type arg1 ;
17241   Dali::Property::Value *result = 0 ;
17242
17243   arg1 = (Dali::Property::Type)jarg1;
17244   {
17245     try {
17246       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17247     } catch (std::out_of_range& e) {
17248       {
17249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17250       };
17251     } catch (std::exception& e) {
17252       {
17253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17254       };
17255     } catch (Dali::DaliException e) {
17256       {
17257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17258       };
17259     } catch (...) {
17260       {
17261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17262       };
17263     }
17264   }
17265
17266   jresult = (void *)result;
17267   return jresult;
17268 }
17269
17270
17271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17272   void * jresult ;
17273   Dali::Property::Value *arg1 = 0 ;
17274   Dali::Property::Value *result = 0 ;
17275
17276   arg1 = (Dali::Property::Value *)jarg1;
17277   if (!arg1) {
17278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17279     return 0;
17280   }
17281   {
17282     try {
17283       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17284     } catch (std::out_of_range& e) {
17285       {
17286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17287       };
17288     } catch (std::exception& e) {
17289       {
17290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17291       };
17292     } catch (Dali::DaliException e) {
17293       {
17294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17295       };
17296     } catch (...) {
17297       {
17298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17299       };
17300     }
17301   }
17302
17303   jresult = (void *)result;
17304   return jresult;
17305 }
17306
17307
17308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17309   void * jresult ;
17310   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17311   Dali::Property::Value *arg2 = 0 ;
17312   Dali::Property::Value *result = 0 ;
17313
17314   arg1 = (Dali::Property::Value *)jarg1;
17315   arg2 = (Dali::Property::Value *)jarg2;
17316   if (!arg2) {
17317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17318     return 0;
17319   }
17320   {
17321     try {
17322       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17323     } catch (std::out_of_range& e) {
17324       {
17325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17326       };
17327     } catch (std::exception& e) {
17328       {
17329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17330       };
17331     } catch (Dali::DaliException e) {
17332       {
17333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17334       };
17335     } catch (...) {
17336       {
17337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17338       };
17339     }
17340   }
17341
17342   jresult = (void *)result;
17343   return jresult;
17344 }
17345
17346
17347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17348   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17349
17350   arg1 = (Dali::Property::Value *)jarg1;
17351   {
17352     try {
17353       delete arg1;
17354     } catch (std::out_of_range& e) {
17355       {
17356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17357       };
17358     } catch (std::exception& e) {
17359       {
17360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17361       };
17362     } catch (Dali::DaliException e) {
17363       {
17364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17365       };
17366     } catch (...) {
17367       {
17368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17369       };
17370     }
17371   }
17372
17373 }
17374
17375
17376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17377   int jresult ;
17378   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17379   Dali::Property::Type result;
17380
17381   arg1 = (Dali::Property::Value *)jarg1;
17382   {
17383     try {
17384       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17385     } catch (std::out_of_range& e) {
17386       {
17387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17388       };
17389     } catch (std::exception& e) {
17390       {
17391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17392       };
17393     } catch (Dali::DaliException e) {
17394       {
17395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17396       };
17397     } catch (...) {
17398       {
17399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17400       };
17401     }
17402   }
17403
17404   jresult = (int)result;
17405   return jresult;
17406 }
17407
17408
17409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17410   unsigned int jresult ;
17411   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17412   bool *arg2 = 0 ;
17413   bool result;
17414
17415   arg1 = (Dali::Property::Value *)jarg1;
17416   arg2 = (bool *)jarg2;
17417   {
17418     try {
17419       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17420     } catch (std::out_of_range& e) {
17421       {
17422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17423       };
17424     } catch (std::exception& e) {
17425       {
17426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17427       };
17428     } catch (Dali::DaliException e) {
17429       {
17430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17431       };
17432     } catch (...) {
17433       {
17434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17435       };
17436     }
17437   }
17438
17439   jresult = result;
17440   return jresult;
17441 }
17442
17443
17444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17445   unsigned int jresult ;
17446   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17447   float *arg2 = 0 ;
17448   bool result;
17449
17450   arg1 = (Dali::Property::Value *)jarg1;
17451   arg2 = (float *)jarg2;
17452   {
17453     try {
17454       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17455     } catch (std::out_of_range& e) {
17456       {
17457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17458       };
17459     } catch (std::exception& e) {
17460       {
17461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17462       };
17463     } catch (Dali::DaliException e) {
17464       {
17465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17466       };
17467     } catch (...) {
17468       {
17469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17470       };
17471     }
17472   }
17473
17474   jresult = result;
17475   return jresult;
17476 }
17477
17478
17479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17480   unsigned int jresult ;
17481   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17482   int *arg2 = 0 ;
17483   bool result;
17484
17485   arg1 = (Dali::Property::Value *)jarg1;
17486   arg2 = (int *)jarg2;
17487   {
17488     try {
17489       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17490     } catch (std::out_of_range& e) {
17491       {
17492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17493       };
17494     } catch (std::exception& e) {
17495       {
17496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17497       };
17498     } catch (Dali::DaliException e) {
17499       {
17500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17501       };
17502     } catch (...) {
17503       {
17504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17505       };
17506     }
17507   }
17508
17509   jresult = result;
17510   return jresult;
17511 }
17512
17513
17514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17515   unsigned int jresult ;
17516   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17517   Dali::Rect< int > *arg2 = 0 ;
17518   bool result;
17519
17520   arg1 = (Dali::Property::Value *)jarg1;
17521   arg2 = (Dali::Rect< int > *)jarg2;
17522   if (!arg2) {
17523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17524     return 0;
17525   }
17526   {
17527     try {
17528       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17529     } catch (std::out_of_range& e) {
17530       {
17531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17532       };
17533     } catch (std::exception& e) {
17534       {
17535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17536       };
17537     } catch (Dali::DaliException e) {
17538       {
17539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17540       };
17541     } catch (...) {
17542       {
17543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17544       };
17545     }
17546   }
17547
17548   jresult = result;
17549   return jresult;
17550 }
17551
17552
17553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17554   unsigned int jresult ;
17555   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17556   Dali::Vector2 *arg2 = 0 ;
17557   bool result;
17558
17559   arg1 = (Dali::Property::Value *)jarg1;
17560   arg2 = (Dali::Vector2 *)jarg2;
17561   if (!arg2) {
17562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17563     return 0;
17564   }
17565   {
17566     try {
17567       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17568     } catch (std::out_of_range& e) {
17569       {
17570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17571       };
17572     } catch (std::exception& e) {
17573       {
17574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17575       };
17576     } catch (Dali::DaliException e) {
17577       {
17578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17579       };
17580     } catch (...) {
17581       {
17582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17583       };
17584     }
17585   }
17586
17587   jresult = result;
17588   return jresult;
17589 }
17590
17591
17592 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17593   unsigned int jresult ;
17594   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17595   Dali::Vector3 *arg2 = 0 ;
17596   bool result;
17597
17598   arg1 = (Dali::Property::Value *)jarg1;
17599   arg2 = (Dali::Vector3 *)jarg2;
17600   if (!arg2) {
17601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17602     return 0;
17603   }
17604   {
17605     try {
17606       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17607     } catch (std::out_of_range& e) {
17608       {
17609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17610       };
17611     } catch (std::exception& e) {
17612       {
17613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17614       };
17615     } catch (Dali::DaliException e) {
17616       {
17617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17618       };
17619     } catch (...) {
17620       {
17621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17622       };
17623     }
17624   }
17625
17626   jresult = result;
17627   return jresult;
17628 }
17629
17630
17631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17632   unsigned int jresult ;
17633   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17634   Dali::Vector4 *arg2 = 0 ;
17635   bool result;
17636
17637   arg1 = (Dali::Property::Value *)jarg1;
17638   arg2 = (Dali::Vector4 *)jarg2;
17639   if (!arg2) {
17640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17641     return 0;
17642   }
17643   {
17644     try {
17645       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17646     } catch (std::out_of_range& e) {
17647       {
17648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17649       };
17650     } catch (std::exception& e) {
17651       {
17652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17653       };
17654     } catch (Dali::DaliException e) {
17655       {
17656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17657       };
17658     } catch (...) {
17659       {
17660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17661       };
17662     }
17663   }
17664
17665   jresult = result;
17666   return jresult;
17667 }
17668
17669
17670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17671   unsigned int jresult ;
17672   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17673   Dali::Matrix3 *arg2 = 0 ;
17674   bool result;
17675
17676   arg1 = (Dali::Property::Value *)jarg1;
17677   arg2 = (Dali::Matrix3 *)jarg2;
17678   if (!arg2) {
17679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17680     return 0;
17681   }
17682   {
17683     try {
17684       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17685     } catch (std::out_of_range& e) {
17686       {
17687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17688       };
17689     } catch (std::exception& e) {
17690       {
17691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17692       };
17693     } catch (Dali::DaliException e) {
17694       {
17695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17696       };
17697     } catch (...) {
17698       {
17699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17700       };
17701     }
17702   }
17703
17704   jresult = result;
17705   return jresult;
17706 }
17707
17708
17709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17710   unsigned int jresult ;
17711   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17712   Dali::Matrix *arg2 = 0 ;
17713   bool result;
17714
17715   arg1 = (Dali::Property::Value *)jarg1;
17716   arg2 = (Dali::Matrix *)jarg2;
17717   if (!arg2) {
17718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17719     return 0;
17720   }
17721   {
17722     try {
17723       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17724     } catch (std::out_of_range& e) {
17725       {
17726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17727       };
17728     } catch (std::exception& e) {
17729       {
17730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17731       };
17732     } catch (Dali::DaliException e) {
17733       {
17734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17735       };
17736     } catch (...) {
17737       {
17738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17739       };
17740     }
17741   }
17742
17743   jresult = result;
17744   return jresult;
17745 }
17746
17747
17748 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17749   unsigned int jresult ;
17750   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17751   Dali::AngleAxis *arg2 = 0 ;
17752   bool result;
17753
17754   arg1 = (Dali::Property::Value *)jarg1;
17755   arg2 = (Dali::AngleAxis *)jarg2;
17756   if (!arg2) {
17757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17758     return 0;
17759   }
17760   {
17761     try {
17762       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17763     } catch (std::out_of_range& e) {
17764       {
17765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17766       };
17767     } catch (std::exception& e) {
17768       {
17769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17770       };
17771     } catch (Dali::DaliException e) {
17772       {
17773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17774       };
17775     } catch (...) {
17776       {
17777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17778       };
17779     }
17780   }
17781
17782   jresult = result;
17783   return jresult;
17784 }
17785
17786
17787 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17788   unsigned int jresult ;
17789   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17790   Dali::Quaternion *arg2 = 0 ;
17791   bool result;
17792
17793   arg1 = (Dali::Property::Value *)jarg1;
17794   arg2 = (Dali::Quaternion *)jarg2;
17795   if (!arg2) {
17796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17797     return 0;
17798   }
17799   {
17800     try {
17801       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17802     } catch (std::out_of_range& e) {
17803       {
17804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17805       };
17806     } catch (std::exception& e) {
17807       {
17808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17809       };
17810     } catch (Dali::DaliException e) {
17811       {
17812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17813       };
17814     } catch (...) {
17815       {
17816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17817       };
17818     }
17819   }
17820
17821   jresult = result;
17822   return jresult;
17823 }
17824
17825
17826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17827   unsigned int jresult ;
17828   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17829   std::string *arg2 = 0 ;
17830   bool result;
17831
17832   arg1 = (Dali::Property::Value *)jarg1;
17833
17834   //typemap in
17835   std::string temp;
17836   arg2 = &temp;
17837
17838   {
17839     try {
17840       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17841     } catch (std::out_of_range& e) {
17842       {
17843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17844       };
17845     } catch (std::exception& e) {
17846       {
17847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17848       };
17849     } catch (Dali::DaliException e) {
17850       {
17851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17852       };
17853     } catch (...) {
17854       {
17855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17856       };
17857     }
17858   }
17859
17860   jresult = result;
17861
17862   //Typemap argout in c++ file.
17863   //This will convert c++ string to c# string
17864   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17865
17866   return jresult;
17867 }
17868
17869
17870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17871   unsigned int jresult ;
17872   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17873   Dali::Property::Array *arg2 = 0 ;
17874   bool result;
17875
17876   arg1 = (Dali::Property::Value *)jarg1;
17877   arg2 = (Dali::Property::Array *)jarg2;
17878   if (!arg2) {
17879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17880     return 0;
17881   }
17882   {
17883     try {
17884       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17885     } catch (std::out_of_range& e) {
17886       {
17887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17888       };
17889     } catch (std::exception& e) {
17890       {
17891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17892       };
17893     } catch (Dali::DaliException e) {
17894       {
17895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17896       };
17897     } catch (...) {
17898       {
17899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17900       };
17901     }
17902   }
17903
17904   jresult = result;
17905   return jresult;
17906 }
17907
17908
17909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17910   unsigned int jresult ;
17911   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17912   Dali::Property::Map *arg2 = 0 ;
17913   bool result;
17914
17915   arg1 = (Dali::Property::Value *)jarg1;
17916   arg2 = (Dali::Property::Map *)jarg2;
17917   if (!arg2) {
17918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17919     return 0;
17920   }
17921   {
17922     try {
17923       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17924     } catch (std::out_of_range& e) {
17925       {
17926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17927       };
17928     } catch (std::exception& e) {
17929       {
17930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17931       };
17932     } catch (Dali::DaliException e) {
17933       {
17934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17935       };
17936     } catch (...) {
17937       {
17938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17939       };
17940     }
17941   }
17942
17943   jresult = result;
17944   return jresult;
17945 }
17946
17947
17948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17949   unsigned int jresult ;
17950   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17951   Extents *arg2 = 0 ;
17952   bool result;
17953
17954   arg1 = (Dali::Property::Value *)jarg1;
17955   arg2 = (Extents *)jarg2;
17956   if (!arg2) {
17957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17958     return 0;
17959   }
17960   {
17961     try {
17962       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17963     } catch (std::out_of_range& e) {
17964       {
17965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17966       };
17967     } catch (std::exception& e) {
17968       {
17969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17970       };
17971     } catch (...) {
17972       {
17973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17974       };
17975     }
17976   }
17977   jresult = result;
17978   return jresult;
17979 }
17980
17981
17982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17983   void * jresult ;
17984   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17985   Dali::Property::Array *result = 0 ;
17986
17987   arg1 = (Dali::Property::Value *)jarg1;
17988   {
17989     try {
17990       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17991     } catch (std::out_of_range& e) {
17992       {
17993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17994       };
17995     } catch (std::exception& e) {
17996       {
17997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17998       };
17999     } catch (Dali::DaliException e) {
18000       {
18001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18002       };
18003     } catch (...) {
18004       {
18005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18006       };
18007     }
18008   }
18009
18010   jresult = (void *)result;
18011   return jresult;
18012 }
18013
18014
18015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
18016   void * jresult ;
18017   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18018   Dali::Property::Map *result = 0 ;
18019
18020   arg1 = (Dali::Property::Value *)jarg1;
18021   {
18022     try {
18023       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
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 char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18049   char * jresult ;
18050   Dali::Property::Type arg1 ;
18051   char *result = 0 ;
18052
18053   arg1 = (Dali::Property::Type)jarg1;
18054   {
18055     try {
18056       result = (char *)Dali::PropertyTypes::GetName(arg1);
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 = SWIG_csharp_string_callback((const char *)result);
18077   return jresult;
18078 }
18079
18080
18081 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18082   unsigned int jresult ;
18083   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18084   std::string *arg2 = 0 ;
18085   Dali::Property::Map *arg3 = 0 ;
18086   bool result;
18087
18088   arg1 = (Dali::BaseObject *)jarg1;
18089   if (!jarg2) {
18090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18091     return 0;
18092   }
18093   std::string arg2_str(jarg2);
18094   arg2 = &arg2_str;
18095   arg3 = (Dali::Property::Map *)jarg3;
18096   if (!arg3) {
18097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18098     return 0;
18099   }
18100   {
18101     try {
18102       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18103     } catch (std::out_of_range& e) {
18104       {
18105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18106       };
18107     } catch (std::exception& e) {
18108       {
18109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18110       };
18111     } catch (Dali::DaliException e) {
18112       {
18113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18114       };
18115     } catch (...) {
18116       {
18117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18118       };
18119     }
18120   }
18121
18122   jresult = result;
18123
18124   //argout typemap for const std::string&
18125
18126   return jresult;
18127 }
18128
18129
18130 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18131   char * jresult ;
18132   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18133   std::string *result = 0 ;
18134
18135   arg1 = (Dali::BaseObject *)jarg1;
18136   {
18137     try {
18138       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18139     } catch (std::out_of_range& e) {
18140       {
18141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18142       };
18143     } catch (std::exception& e) {
18144       {
18145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18146       };
18147     } catch (Dali::DaliException e) {
18148       {
18149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18150       };
18151     } catch (...) {
18152       {
18153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18154       };
18155     }
18156   }
18157
18158   jresult = SWIG_csharp_string_callback(result->c_str());
18159   return jresult;
18160 }
18161
18162
18163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18164   unsigned int jresult ;
18165   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18166   Dali::TypeInfo *arg2 = 0 ;
18167   bool result;
18168
18169   arg1 = (Dali::BaseObject *)jarg1;
18170   arg2 = (Dali::TypeInfo *)jarg2;
18171   if (!arg2) {
18172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18173     return 0;
18174   }
18175   {
18176     try {
18177       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18178     } catch (std::out_of_range& e) {
18179       {
18180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18181       };
18182     } catch (std::exception& e) {
18183       {
18184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18185       };
18186     } catch (Dali::DaliException e) {
18187       {
18188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18189       };
18190     } catch (...) {
18191       {
18192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18193       };
18194     }
18195   }
18196
18197   jresult = result;
18198   return jresult;
18199 }
18200
18201
18202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18203   unsigned int jresult ;
18204   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18205   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18206   std::string *arg3 = 0 ;
18207   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18208   bool result;
18209
18210   arg1 = (Dali::BaseObject *)jarg1;
18211   arg2 = (ConnectionTrackerInterface *)jarg2;
18212   if (!jarg3) {
18213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18214     return 0;
18215   }
18216   std::string arg3_str(jarg3);
18217   arg3 = &arg3_str;
18218   arg4 = (FunctorDelegate *)jarg4;
18219   {
18220     try {
18221       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18222     } catch (std::out_of_range& e) {
18223       {
18224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18225       };
18226     } catch (std::exception& e) {
18227       {
18228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18229       };
18230     } catch (Dali::DaliException e) {
18231       {
18232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18233       };
18234     } catch (...) {
18235       {
18236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18237       };
18238     }
18239   }
18240
18241   jresult = result;
18242
18243   //argout typemap for const std::string&
18244
18245   return jresult;
18246 }
18247
18248
18249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18250   void * jresult ;
18251   Dali::BaseHandle *arg1 = 0 ;
18252   Dali::BaseObject *result = 0 ;
18253
18254   arg1 = (Dali::BaseHandle *)jarg1;
18255   if (!arg1) {
18256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18257     return 0;
18258   }
18259   {
18260     try {
18261       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18262     } catch (std::out_of_range& e) {
18263       {
18264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18265       };
18266     } catch (std::exception& e) {
18267       {
18268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18269       };
18270     } catch (Dali::DaliException e) {
18271       {
18272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18273       };
18274     } catch (...) {
18275       {
18276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18277       };
18278     }
18279   }
18280
18281   jresult = (void *)result;
18282   return jresult;
18283 }
18284
18285
18286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18287   void * jresult ;
18288   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18289   Dali::BaseHandle *result = 0 ;
18290
18291   arg1 = (Dali::BaseObject *)jarg1;
18292   {
18293     try {
18294       result = (Dali::BaseHandle *)new Dali::BaseHandle(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_1() {
18320   void * jresult ;
18321   Dali::BaseHandle *result = 0 ;
18322
18323   {
18324     try {
18325       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18326     } catch (std::out_of_range& e) {
18327       {
18328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18329       };
18330     } catch (std::exception& e) {
18331       {
18332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18333       };
18334     } catch (Dali::DaliException e) {
18335       {
18336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18337       };
18338     } catch (...) {
18339       {
18340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18341       };
18342     }
18343   }
18344
18345   jresult = (void *)result;
18346   return jresult;
18347 }
18348
18349
18350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18351   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18352
18353   arg1 = (Dali::BaseHandle *)jarg1;
18354   {
18355     try {
18356       delete arg1;
18357     } catch (std::out_of_range& e) {
18358       {
18359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18360       };
18361     } catch (std::exception& e) {
18362       {
18363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18364       };
18365     } catch (Dali::DaliException e) {
18366       {
18367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18368       };
18369     } catch (...) {
18370       {
18371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18372       };
18373     }
18374   }
18375
18376 }
18377
18378
18379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18380   void * jresult ;
18381   Dali::BaseHandle *arg1 = 0 ;
18382   Dali::BaseHandle *result = 0 ;
18383
18384   arg1 = (Dali::BaseHandle *)jarg1;
18385   if (!arg1) {
18386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18387     return 0;
18388   }
18389   {
18390     try {
18391       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18392     } catch (std::out_of_range& e) {
18393       {
18394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18395       };
18396     } catch (std::exception& e) {
18397       {
18398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18399       };
18400     } catch (Dali::DaliException e) {
18401       {
18402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18403       };
18404     } catch (...) {
18405       {
18406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18407       };
18408     }
18409   }
18410
18411   jresult = (void *)result;
18412   return jresult;
18413 }
18414
18415
18416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18417   void * jresult ;
18418   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18419   Dali::BaseHandle *arg2 = 0 ;
18420   Dali::BaseHandle *result = 0 ;
18421
18422   arg1 = (Dali::BaseHandle *)jarg1;
18423   arg2 = (Dali::BaseHandle *)jarg2;
18424   if (!arg2) {
18425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18426     return 0;
18427   }
18428   {
18429     try {
18430       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18431     } catch (std::out_of_range& e) {
18432       {
18433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18434       };
18435     } catch (std::exception& e) {
18436       {
18437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18438       };
18439     } catch (Dali::DaliException e) {
18440       {
18441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18442       };
18443     } catch (...) {
18444       {
18445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18446       };
18447     }
18448   }
18449
18450   jresult = (void *)result;
18451   return jresult;
18452 }
18453
18454
18455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18456   unsigned int jresult ;
18457   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18458   std::string *arg2 = 0 ;
18459   Dali::Property::Map *arg3 = 0 ;
18460   bool result;
18461
18462   arg1 = (Dali::BaseHandle *)jarg1;
18463   if (!jarg2) {
18464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18465     return 0;
18466   }
18467   std::string arg2_str(jarg2);
18468   arg2 = &arg2_str;
18469   arg3 = (Dali::Property::Map *)jarg3;
18470   if (!arg3) {
18471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18472     return 0;
18473   }
18474   {
18475     try {
18476       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18477     } catch (std::out_of_range& e) {
18478       {
18479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18480       };
18481     } catch (std::exception& e) {
18482       {
18483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18484       };
18485     } catch (Dali::DaliException e) {
18486       {
18487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18488       };
18489     } catch (...) {
18490       {
18491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18492       };
18493     }
18494   }
18495
18496   jresult = result;
18497
18498   //argout typemap for const std::string&
18499
18500   return jresult;
18501 }
18502
18503
18504 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18505   char * jresult ;
18506   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18507   std::string *result = 0 ;
18508
18509   arg1 = (Dali::BaseHandle *)jarg1;
18510   {
18511     try {
18512       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18513     } catch (std::out_of_range& e) {
18514       {
18515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18516       };
18517     } catch (std::exception& e) {
18518       {
18519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18520       };
18521     } catch (Dali::DaliException e) {
18522       {
18523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18524       };
18525     } catch (...) {
18526       {
18527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18528       };
18529     }
18530   }
18531
18532   jresult = SWIG_csharp_string_callback(result->c_str());
18533   return jresult;
18534 }
18535
18536
18537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18538   unsigned int jresult ;
18539   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18540   Dali::TypeInfo *arg2 = 0 ;
18541   bool result;
18542
18543   arg1 = (Dali::BaseHandle *)jarg1;
18544   arg2 = (Dali::TypeInfo *)jarg2;
18545   if (!arg2) {
18546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18547     return 0;
18548   }
18549   {
18550     try {
18551       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18552     } catch (std::out_of_range& e) {
18553       {
18554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18555       };
18556     } catch (std::exception& e) {
18557       {
18558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18559       };
18560     } catch (Dali::DaliException e) {
18561       {
18562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18563       };
18564     } catch (...) {
18565       {
18566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18567       };
18568     }
18569   }
18570
18571   jresult = result;
18572   return jresult;
18573 }
18574
18575
18576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18577   void * jresult ;
18578   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18579   Dali::BaseObject *result = 0 ;
18580
18581   arg1 = (Dali::BaseHandle *)jarg1;
18582   {
18583     try {
18584       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
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 = (void *)result;
18605   return jresult;
18606 }
18607
18608
18609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18610   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18611
18612   arg1 = (Dali::BaseHandle *)jarg1;
18613   {
18614     try {
18615       (arg1)->Reset();
18616     } catch (std::out_of_range& e) {
18617       {
18618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18619       };
18620     } catch (std::exception& e) {
18621       {
18622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18623       };
18624     } catch (Dali::DaliException e) {
18625       {
18626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18627       };
18628     } catch (...) {
18629       {
18630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18631       };
18632     }
18633   }
18634
18635 }
18636
18637
18638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18639   unsigned int jresult ;
18640   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18641   Dali::BaseHandle *arg2 = 0 ;
18642   bool result;
18643
18644   arg1 = (Dali::BaseHandle *)jarg1;
18645   arg2 = (Dali::BaseHandle *)jarg2;
18646   if (!arg2) {
18647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18648     return 0;
18649   }
18650   {
18651     try {
18652       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18653     } catch (std::out_of_range& e) {
18654       {
18655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18656       };
18657     } catch (std::exception& e) {
18658       {
18659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18660       };
18661     } catch (Dali::DaliException e) {
18662       {
18663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18664       };
18665     } catch (...) {
18666       {
18667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18668       };
18669     }
18670   }
18671
18672   jresult = result;
18673   return jresult;
18674 }
18675
18676
18677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18678   unsigned int jresult ;
18679   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18680   Dali::BaseHandle *arg2 = 0 ;
18681   bool result;
18682
18683   arg1 = (Dali::BaseHandle *)jarg1;
18684   arg2 = (Dali::BaseHandle *)jarg2;
18685   if (!arg2) {
18686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18687     return 0;
18688   }
18689   {
18690     try {
18691       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18692     } catch (std::out_of_range& e) {
18693       {
18694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18695       };
18696     } catch (std::exception& e) {
18697       {
18698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18699       };
18700     } catch (Dali::DaliException e) {
18701       {
18702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18703       };
18704     } catch (...) {
18705       {
18706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18707       };
18708     }
18709   }
18710
18711   jresult = result;
18712   return jresult;
18713 }
18714
18715
18716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18717   void * jresult ;
18718   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18719   Dali::RefObject *result = 0 ;
18720
18721   arg1 = (Dali::BaseHandle *)jarg1;
18722   {
18723     try {
18724       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
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 = (void *)result;
18745   return jresult;
18746 }
18747
18748
18749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18750   unsigned int jresult ;
18751   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18752   bool result;
18753
18754   arg1 = (Dali::BaseHandle *)jarg1;
18755   {
18756     try {
18757       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
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 = result;
18778   return jresult;
18779 }
18780
18781
18782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18783   unsigned int jresult ;
18784   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18785   Dali::BaseHandle *arg2 = 0 ;
18786   bool result;
18787
18788   arg1 = (Dali::BaseHandle *)jarg1;
18789   arg2 = (Dali::BaseHandle *)jarg2;
18790   if (!arg2) {
18791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18792     return 0;
18793   }
18794   {
18795     try {
18796       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18797     } catch (std::out_of_range& e) {
18798       {
18799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18800       };
18801     } catch (std::exception& e) {
18802       {
18803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18804       };
18805     } catch (Dali::DaliException e) {
18806       {
18807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18808       };
18809     } catch (...) {
18810       {
18811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18812       };
18813     }
18814   }
18815
18816   jresult = result;
18817   return jresult;
18818 }
18819
18820
18821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18822   unsigned int jresult ;
18823   Dali::BaseHandle *arg1 = 0 ;
18824   Dali::BaseHandle *arg2 = 0 ;
18825   bool result;
18826
18827   arg1 = (Dali::BaseHandle *)jarg1;
18828   if (!arg1) {
18829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18830     return 0;
18831   }
18832   arg2 = (Dali::BaseHandle *)jarg2;
18833   if (!arg2) {
18834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18835     return 0;
18836   }
18837   {
18838     try {
18839       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18840     } catch (std::out_of_range& e) {
18841       {
18842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18843       };
18844     } catch (std::exception& e) {
18845       {
18846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18847       };
18848     } catch (Dali::DaliException e) {
18849       {
18850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18851       };
18852     } catch (...) {
18853       {
18854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18855       };
18856     }
18857   }
18858
18859   jresult = result;
18860   return jresult;
18861 }
18862
18863
18864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18865   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18866
18867   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18868   {
18869     try {
18870       delete arg1;
18871     } catch (std::out_of_range& e) {
18872       {
18873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18874       };
18875     } catch (std::exception& e) {
18876       {
18877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18878       };
18879     } catch (Dali::DaliException e) {
18880       {
18881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18882       };
18883     } catch (...) {
18884       {
18885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18886       };
18887     }
18888   }
18889
18890 }
18891
18892
18893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18894   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18895   SlotObserver *arg2 = (SlotObserver *) 0 ;
18896   CallbackBase *arg3 = (CallbackBase *) 0 ;
18897
18898   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18899   arg2 = (SlotObserver *)jarg2;
18900   arg3 = (CallbackBase *)jarg3;
18901   {
18902     try {
18903       (arg1)->SignalConnected(arg2,arg3);
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_delete_SignalObserver(void * jarg1) {
18927   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18928
18929   arg1 = (Dali::SignalObserver *)jarg1;
18930   {
18931     try {
18932       delete arg1;
18933     } catch (std::out_of_range& e) {
18934       {
18935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18936       };
18937     } catch (std::exception& e) {
18938       {
18939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18940       };
18941     } catch (Dali::DaliException e) {
18942       {
18943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18944       };
18945     } catch (...) {
18946       {
18947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18948       };
18949     }
18950   }
18951
18952 }
18953
18954
18955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18956   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18957   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18958   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18959
18960   arg1 = (Dali::SignalObserver *)jarg1;
18961   arg2 = (Dali::SlotObserver *)jarg2;
18962   arg3 = (Dali::CallbackBase *)jarg3;
18963   {
18964     try {
18965       (arg1)->SignalDisconnected(arg2,arg3);
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_delete_SlotObserver(void * jarg1) {
18989   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18990
18991   arg1 = (Dali::SlotObserver *)jarg1;
18992   {
18993     try {
18994       delete arg1;
18995     } catch (std::out_of_range& e) {
18996       {
18997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18998       };
18999     } catch (std::exception& e) {
19000       {
19001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19002       };
19003     } catch (Dali::DaliException e) {
19004       {
19005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19006       };
19007     } catch (...) {
19008       {
19009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19010       };
19011     }
19012   }
19013
19014 }
19015
19016
19017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19018   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19019   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19020
19021   arg1 = (Dali::SlotObserver *)jarg1;
19022   arg2 = (Dali::CallbackBase *)jarg2;
19023   {
19024     try {
19025       (arg1)->SlotDisconnected(arg2);
19026     } catch (std::out_of_range& e) {
19027       {
19028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19029       };
19030     } catch (std::exception& e) {
19031       {
19032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19033       };
19034     } catch (Dali::DaliException e) {
19035       {
19036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19037       };
19038     } catch (...) {
19039       {
19040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19041       };
19042     }
19043   }
19044
19045 }
19046
19047
19048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19049   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19050
19051   arg1 = (Dali::ConnectionTracker *)jarg1;
19052   {
19053     try {
19054       delete arg1;
19055     } catch (std::out_of_range& e) {
19056       {
19057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19058       };
19059     } catch (std::exception& e) {
19060       {
19061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19062       };
19063     } catch (Dali::DaliException e) {
19064       {
19065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19066       };
19067     } catch (...) {
19068       {
19069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19070       };
19071     }
19072   }
19073
19074 }
19075
19076
19077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19078   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19079
19080   arg1 = (Dali::ConnectionTracker *)jarg1;
19081   {
19082     try {
19083       (arg1)->DisconnectAll();
19084     } catch (std::out_of_range& e) {
19085       {
19086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19087       };
19088     } catch (std::exception& e) {
19089       {
19090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19091       };
19092     } catch (Dali::DaliException e) {
19093       {
19094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19095       };
19096     } catch (...) {
19097       {
19098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19099       };
19100     }
19101   }
19102
19103 }
19104
19105
19106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19107   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19108   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19109   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19110
19111   arg1 = (Dali::ConnectionTracker *)jarg1;
19112   arg2 = (Dali::SlotObserver *)jarg2;
19113   arg3 = (Dali::CallbackBase *)jarg3;
19114   {
19115     try {
19116       (arg1)->SignalConnected(arg2,arg3);
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_SignalDisconnected(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)->SignalDisconnected(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 unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19173   unsigned long jresult ;
19174   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19175   std::size_t result;
19176
19177   arg1 = (Dali::ConnectionTracker *)jarg1;
19178   {
19179     try {
19180       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19181     } catch (std::out_of_range& e) {
19182       {
19183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19184       };
19185     } catch (std::exception& e) {
19186       {
19187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19188       };
19189     } catch (Dali::DaliException e) {
19190       {
19191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19192       };
19193     } catch (...) {
19194       {
19195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19196       };
19197     }
19198   }
19199
19200   jresult = (unsigned long)result;
19201   return jresult;
19202 }
19203
19204
19205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19206   void * jresult ;
19207   Dali::ObjectRegistry *result = 0 ;
19208
19209   {
19210     try {
19211       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19212     } catch (std::out_of_range& e) {
19213       {
19214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19215       };
19216     } catch (std::exception& e) {
19217       {
19218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19219       };
19220     } catch (Dali::DaliException e) {
19221       {
19222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19223       };
19224     } catch (...) {
19225       {
19226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19227       };
19228     }
19229   }
19230
19231   jresult = (void *)result;
19232   return jresult;
19233 }
19234
19235
19236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19237   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19238
19239   arg1 = (Dali::ObjectRegistry *)jarg1;
19240   {
19241     try {
19242       delete arg1;
19243     } catch (std::out_of_range& e) {
19244       {
19245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19246       };
19247     } catch (std::exception& e) {
19248       {
19249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19250       };
19251     } catch (Dali::DaliException e) {
19252       {
19253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19254       };
19255     } catch (...) {
19256       {
19257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19258       };
19259     }
19260   }
19261
19262 }
19263
19264
19265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19266   void * jresult ;
19267   Dali::ObjectRegistry *arg1 = 0 ;
19268   Dali::ObjectRegistry *result = 0 ;
19269
19270   arg1 = (Dali::ObjectRegistry *)jarg1;
19271   if (!arg1) {
19272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19273     return 0;
19274   }
19275   {
19276     try {
19277       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19278     } catch (std::out_of_range& e) {
19279       {
19280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19281       };
19282     } catch (std::exception& e) {
19283       {
19284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19285       };
19286     } catch (Dali::DaliException e) {
19287       {
19288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19289       };
19290     } catch (...) {
19291       {
19292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19293       };
19294     }
19295   }
19296
19297   jresult = (void *)result;
19298   return jresult;
19299 }
19300
19301
19302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19303   void * jresult ;
19304   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19305   Dali::ObjectRegistry *arg2 = 0 ;
19306   Dali::ObjectRegistry *result = 0 ;
19307
19308   arg1 = (Dali::ObjectRegistry *)jarg1;
19309   arg2 = (Dali::ObjectRegistry *)jarg2;
19310   if (!arg2) {
19311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19312     return 0;
19313   }
19314   {
19315     try {
19316       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19317     } catch (std::out_of_range& e) {
19318       {
19319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19320       };
19321     } catch (std::exception& e) {
19322       {
19323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19324       };
19325     } catch (Dali::DaliException e) {
19326       {
19327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19328       };
19329     } catch (...) {
19330       {
19331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19332       };
19333     }
19334   }
19335
19336   jresult = (void *)result;
19337   return jresult;
19338 }
19339
19340
19341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19342   void * jresult ;
19343   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19344   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19345
19346   arg1 = (Dali::ObjectRegistry *)jarg1;
19347   {
19348     try {
19349       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
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_ObjectDestroyedSignal(void * jarg1) {
19375   void * jresult ;
19376   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19377   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19378
19379   arg1 = (Dali::ObjectRegistry *)jarg1;
19380   {
19381     try {
19382       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
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_new_PropertyCondition__SWIG_0() {
19408   void * jresult ;
19409   Dali::PropertyCondition *result = 0 ;
19410
19411   {
19412     try {
19413       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19414     } catch (std::out_of_range& e) {
19415       {
19416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19417       };
19418     } catch (std::exception& e) {
19419       {
19420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19421       };
19422     } catch (Dali::DaliException e) {
19423       {
19424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19425       };
19426     } catch (...) {
19427       {
19428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19429       };
19430     }
19431   }
19432
19433   jresult = (void *)result;
19434   return jresult;
19435 }
19436
19437
19438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19439   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19440
19441   arg1 = (Dali::PropertyCondition *)jarg1;
19442   {
19443     try {
19444       delete arg1;
19445     } catch (std::out_of_range& e) {
19446       {
19447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19448       };
19449     } catch (std::exception& e) {
19450       {
19451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19452       };
19453     } catch (Dali::DaliException e) {
19454       {
19455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19456       };
19457     } catch (...) {
19458       {
19459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19460       };
19461     }
19462   }
19463
19464 }
19465
19466
19467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19468   void * jresult ;
19469   Dali::PropertyCondition *arg1 = 0 ;
19470   Dali::PropertyCondition *result = 0 ;
19471
19472   arg1 = (Dali::PropertyCondition *)jarg1;
19473   if (!arg1) {
19474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19475     return 0;
19476   }
19477   {
19478     try {
19479       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19480     } catch (std::out_of_range& e) {
19481       {
19482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19483       };
19484     } catch (std::exception& e) {
19485       {
19486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19487       };
19488     } catch (Dali::DaliException e) {
19489       {
19490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19491       };
19492     } catch (...) {
19493       {
19494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19495       };
19496     }
19497   }
19498
19499   jresult = (void *)result;
19500   return jresult;
19501 }
19502
19503
19504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19505   void * jresult ;
19506   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19507   Dali::PropertyCondition *arg2 = 0 ;
19508   Dali::PropertyCondition *result = 0 ;
19509
19510   arg1 = (Dali::PropertyCondition *)jarg1;
19511   arg2 = (Dali::PropertyCondition *)jarg2;
19512   if (!arg2) {
19513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19514     return 0;
19515   }
19516   {
19517     try {
19518       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19519     } catch (std::out_of_range& e) {
19520       {
19521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19522       };
19523     } catch (std::exception& e) {
19524       {
19525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19526       };
19527     } catch (Dali::DaliException e) {
19528       {
19529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19530       };
19531     } catch (...) {
19532       {
19533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19534       };
19535     }
19536   }
19537
19538   jresult = (void *)result;
19539   return jresult;
19540 }
19541
19542
19543 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19544   unsigned long jresult ;
19545   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19546   std::size_t result;
19547
19548   arg1 = (Dali::PropertyCondition *)jarg1;
19549   {
19550     try {
19551       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
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 (...) {
19561       {
19562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19563       };
19564     }
19565   }
19566   jresult = (unsigned long)result;
19567   return jresult;
19568 }
19569
19570
19571 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19572   float jresult ;
19573   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19574   std::size_t arg2 ;
19575   float result;
19576
19577   arg1 = (Dali::PropertyCondition *)jarg1;
19578   arg2 = (std::size_t)jarg2;
19579   {
19580     try {
19581       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19582     } catch (std::out_of_range& e) {
19583       {
19584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19585       };
19586     } catch (std::exception& e) {
19587       {
19588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19589       };
19590     } catch (...) {
19591       {
19592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19593       };
19594     }
19595   }
19596   jresult = result;
19597   return jresult;
19598 }
19599
19600
19601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19602   void * jresult ;
19603   float arg1 ;
19604   Dali::PropertyCondition result;
19605
19606   arg1 = (float)jarg1;
19607   {
19608     try {
19609       result = Dali::LessThanCondition(arg1);
19610     } catch (std::out_of_range& e) {
19611       {
19612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19613       };
19614     } catch (std::exception& e) {
19615       {
19616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19617       };
19618     } catch (Dali::DaliException e) {
19619       {
19620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19621       };
19622     } catch (...) {
19623       {
19624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19625       };
19626     }
19627   }
19628
19629   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19630   return jresult;
19631 }
19632
19633
19634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19635   void * jresult ;
19636   float arg1 ;
19637   Dali::PropertyCondition result;
19638
19639   arg1 = (float)jarg1;
19640   {
19641     try {
19642       result = Dali::GreaterThanCondition(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_InsideCondition(float jarg1, float jarg2) {
19668   void * jresult ;
19669   float arg1 ;
19670   float arg2 ;
19671   Dali::PropertyCondition result;
19672
19673   arg1 = (float)jarg1;
19674   arg2 = (float)jarg2;
19675   {
19676     try {
19677       result = Dali::InsideCondition(arg1,arg2);
19678     } catch (std::out_of_range& e) {
19679       {
19680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19681       };
19682     } catch (std::exception& e) {
19683       {
19684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19685       };
19686     } catch (Dali::DaliException e) {
19687       {
19688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19689       };
19690     } catch (...) {
19691       {
19692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19693       };
19694     }
19695   }
19696
19697   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19698   return jresult;
19699 }
19700
19701
19702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19703   void * jresult ;
19704   float arg1 ;
19705   float arg2 ;
19706   Dali::PropertyCondition result;
19707
19708   arg1 = (float)jarg1;
19709   arg2 = (float)jarg2;
19710   {
19711     try {
19712       result = Dali::OutsideCondition(arg1,arg2);
19713     } catch (std::out_of_range& e) {
19714       {
19715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19716       };
19717     } catch (std::exception& e) {
19718       {
19719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19720       };
19721     } catch (Dali::DaliException e) {
19722       {
19723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19724       };
19725     } catch (...) {
19726       {
19727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19728       };
19729     }
19730   }
19731
19732   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19733   return jresult;
19734 }
19735
19736
19737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19738   void * jresult ;
19739   float arg1 ;
19740   float arg2 ;
19741   Dali::PropertyCondition result;
19742
19743   arg1 = (float)jarg1;
19744   arg2 = (float)jarg2;
19745   {
19746     try {
19747       result = Dali::StepCondition(arg1,arg2);
19748     } catch (std::out_of_range& e) {
19749       {
19750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19751       };
19752     } catch (std::exception& e) {
19753       {
19754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19755       };
19756     } catch (Dali::DaliException e) {
19757       {
19758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19759       };
19760     } catch (...) {
19761       {
19762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19763       };
19764     }
19765   }
19766
19767   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19768   return jresult;
19769 }
19770
19771
19772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19773   void * jresult ;
19774   float arg1 ;
19775   Dali::PropertyCondition result;
19776
19777   arg1 = (float)jarg1;
19778   {
19779     try {
19780       result = Dali::StepCondition(arg1);
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_VariableStepCondition(void * jarg1) {
19806   void * jresult ;
19807   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19808   Dali::PropertyCondition result;
19809
19810   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19811   if (!arg1) {
19812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19813     return 0;
19814   }
19815   {
19816     try {
19817       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19818     } catch (std::out_of_range& e) {
19819       {
19820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19821       };
19822     } catch (std::exception& e) {
19823       {
19824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19825       };
19826     } catch (Dali::DaliException e) {
19827       {
19828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19829       };
19830     } catch (...) {
19831       {
19832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19833       };
19834     }
19835   }
19836
19837   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19838   return jresult;
19839 }
19840
19841
19842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19843   void * jresult ;
19844   Dali::PropertyNotification *result = 0 ;
19845
19846   {
19847     try {
19848       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19849     } catch (std::out_of_range& e) {
19850       {
19851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19852       };
19853     } catch (std::exception& e) {
19854       {
19855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19856       };
19857     } catch (Dali::DaliException e) {
19858       {
19859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19860       };
19861     } catch (...) {
19862       {
19863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19864       };
19865     }
19866   }
19867
19868   jresult = (void *)result;
19869   return jresult;
19870 }
19871
19872
19873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19874   void * jresult ;
19875   Dali::BaseHandle arg1 ;
19876   Dali::BaseHandle *argp1 ;
19877   Dali::PropertyNotification result;
19878
19879   argp1 = (Dali::BaseHandle *)jarg1;
19880   if (!argp1) {
19881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19882     return 0;
19883   }
19884   arg1 = *argp1;
19885   {
19886     try {
19887       result = Dali::PropertyNotification::DownCast(arg1);
19888     } catch (std::out_of_range& e) {
19889       {
19890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19891       };
19892     } catch (std::exception& e) {
19893       {
19894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19895       };
19896     } catch (Dali::DaliException e) {
19897       {
19898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19899       };
19900     } catch (...) {
19901       {
19902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19903       };
19904     }
19905   }
19906
19907   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19908   return jresult;
19909 }
19910
19911
19912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19913   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19914
19915   arg1 = (Dali::PropertyNotification *)jarg1;
19916   {
19917     try {
19918       delete arg1;
19919     } catch (std::out_of_range& e) {
19920       {
19921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19922       };
19923     } catch (std::exception& e) {
19924       {
19925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19926       };
19927     } catch (Dali::DaliException e) {
19928       {
19929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19930       };
19931     } catch (...) {
19932       {
19933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19934       };
19935     }
19936   }
19937
19938 }
19939
19940
19941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19942   void * jresult ;
19943   Dali::PropertyNotification *arg1 = 0 ;
19944   Dali::PropertyNotification *result = 0 ;
19945
19946   arg1 = (Dali::PropertyNotification *)jarg1;
19947   if (!arg1) {
19948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19949     return 0;
19950   }
19951   {
19952     try {
19953       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19954     } catch (std::out_of_range& e) {
19955       {
19956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19957       };
19958     } catch (std::exception& e) {
19959       {
19960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19961       };
19962     } catch (Dali::DaliException e) {
19963       {
19964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19965       };
19966     } catch (...) {
19967       {
19968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19969       };
19970     }
19971   }
19972
19973   jresult = (void *)result;
19974   return jresult;
19975 }
19976
19977
19978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19979   void * jresult ;
19980   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19981   Dali::PropertyNotification *arg2 = 0 ;
19982   Dali::PropertyNotification *result = 0 ;
19983
19984   arg1 = (Dali::PropertyNotification *)jarg1;
19985   arg2 = (Dali::PropertyNotification *)jarg2;
19986   if (!arg2) {
19987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19988     return 0;
19989   }
19990   {
19991     try {
19992       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19993     } catch (std::out_of_range& e) {
19994       {
19995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19996       };
19997     } catch (std::exception& e) {
19998       {
19999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20000       };
20001     } catch (Dali::DaliException e) {
20002       {
20003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20004       };
20005     } catch (...) {
20006       {
20007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20008       };
20009     }
20010   }
20011
20012   jresult = (void *)result;
20013   return jresult;
20014 }
20015
20016
20017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20018   void * jresult ;
20019   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20020   Dali::PropertyCondition result;
20021
20022   arg1 = (Dali::PropertyNotification *)jarg1;
20023   {
20024     try {
20025       result = (arg1)->GetCondition();
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 = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20046   return jresult;
20047 }
20048
20049
20050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20051   void * jresult ;
20052   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20053   Dali::Handle result;
20054
20055   arg1 = (Dali::PropertyNotification *)jarg1;
20056   {
20057     try {
20058       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
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::Handle((const Dali::Handle &)result);
20079   return jresult;
20080 }
20081
20082
20083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20084   int jresult ;
20085   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20086   Dali::Property::Index result;
20087
20088   arg1 = (Dali::PropertyNotification *)jarg1;
20089   {
20090     try {
20091       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
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 = result;
20112   return jresult;
20113 }
20114
20115
20116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20117   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20118   Dali::PropertyNotification::NotifyMode arg2 ;
20119
20120   arg1 = (Dali::PropertyNotification *)jarg1;
20121   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20122   {
20123     try {
20124       (arg1)->SetNotifyMode(arg2);
20125     } catch (std::out_of_range& e) {
20126       {
20127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20128       };
20129     } catch (std::exception& e) {
20130       {
20131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20132       };
20133     } catch (Dali::DaliException e) {
20134       {
20135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20136       };
20137     } catch (...) {
20138       {
20139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20140       };
20141     }
20142   }
20143
20144 }
20145
20146
20147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20148   int jresult ;
20149   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20150   Dali::PropertyNotification::NotifyMode result;
20151
20152   arg1 = (Dali::PropertyNotification *)jarg1;
20153   {
20154     try {
20155       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20156     } catch (std::out_of_range& e) {
20157       {
20158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20159       };
20160     } catch (std::exception& e) {
20161       {
20162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20163       };
20164     } catch (Dali::DaliException e) {
20165       {
20166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20167       };
20168     } catch (...) {
20169       {
20170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20171       };
20172     }
20173   }
20174
20175   jresult = (int)result;
20176   return jresult;
20177 }
20178
20179
20180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20181   unsigned int jresult ;
20182   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20183   bool result;
20184
20185   arg1 = (Dali::PropertyNotification *)jarg1;
20186   {
20187     try {
20188       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
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 = result;
20209   return jresult;
20210 }
20211
20212
20213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20214   void * jresult ;
20215   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20216   Dali::PropertyNotifySignalType *result = 0 ;
20217
20218   arg1 = (Dali::PropertyNotification *)jarg1;
20219   {
20220     try {
20221       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
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 = (void *)result;
20242   return jresult;
20243 }
20244
20245
20246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20247   void * jresult ;
20248   Dali::Handle *result = 0 ;
20249
20250   {
20251     try {
20252       result = (Dali::Handle *)new Dali::Handle();
20253     } catch (std::out_of_range& e) {
20254       {
20255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20256       };
20257     } catch (std::exception& e) {
20258       {
20259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20260       };
20261     } catch (Dali::DaliException e) {
20262       {
20263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20264       };
20265     } catch (...) {
20266       {
20267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20268       };
20269     }
20270   }
20271
20272   jresult = (void *)result;
20273   return jresult;
20274 }
20275
20276
20277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20278   void * jresult ;
20279   Dali::Handle result;
20280
20281   {
20282     try {
20283       result = Dali::Handle::New();
20284     } catch (std::out_of_range& e) {
20285       {
20286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20287       };
20288     } catch (std::exception& e) {
20289       {
20290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20291       };
20292     } catch (Dali::DaliException e) {
20293       {
20294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20295       };
20296     } catch (...) {
20297       {
20298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20299       };
20300     }
20301   }
20302
20303   jresult = new Dali::Handle((const Dali::Handle &)result);
20304   return jresult;
20305 }
20306
20307
20308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20309   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20310
20311   arg1 = (Dali::Handle *)jarg1;
20312   {
20313     try {
20314       delete arg1;
20315     } catch (std::out_of_range& e) {
20316       {
20317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20318       };
20319     } catch (std::exception& e) {
20320       {
20321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20322       };
20323     } catch (Dali::DaliException e) {
20324       {
20325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20326       };
20327     } catch (...) {
20328       {
20329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20330       };
20331     }
20332   }
20333
20334 }
20335
20336
20337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20338   void * jresult ;
20339   Dali::Handle *arg1 = 0 ;
20340   Dali::Handle *result = 0 ;
20341
20342   arg1 = (Dali::Handle *)jarg1;
20343   if (!arg1) {
20344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20345     return 0;
20346   }
20347   {
20348     try {
20349       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20350     } catch (std::out_of_range& e) {
20351       {
20352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20353       };
20354     } catch (std::exception& e) {
20355       {
20356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20357       };
20358     } catch (Dali::DaliException e) {
20359       {
20360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20361       };
20362     } catch (...) {
20363       {
20364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20365       };
20366     }
20367   }
20368
20369   jresult = (void *)result;
20370   return jresult;
20371 }
20372
20373
20374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20375   void * jresult ;
20376   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20377   Dali::Handle *arg2 = 0 ;
20378   Dali::Handle *result = 0 ;
20379
20380   arg1 = (Dali::Handle *)jarg1;
20381   arg2 = (Dali::Handle *)jarg2;
20382   if (!arg2) {
20383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20384     return 0;
20385   }
20386   {
20387     try {
20388       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20389     } catch (std::out_of_range& e) {
20390       {
20391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20392       };
20393     } catch (std::exception& e) {
20394       {
20395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20396       };
20397     } catch (Dali::DaliException e) {
20398       {
20399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20400       };
20401     } catch (...) {
20402       {
20403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20404       };
20405     }
20406   }
20407
20408   jresult = (void *)result;
20409   return jresult;
20410 }
20411
20412
20413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20414   void * jresult ;
20415   Dali::BaseHandle arg1 ;
20416   Dali::BaseHandle *argp1 ;
20417   Dali::Handle result;
20418
20419   argp1 = (Dali::BaseHandle *)jarg1;
20420   if (!argp1) {
20421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20422     return 0;
20423   }
20424   arg1 = *argp1;
20425   {
20426     try {
20427       result = Dali::Handle::DownCast(arg1);
20428     } catch (std::out_of_range& e) {
20429       {
20430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20431       };
20432     } catch (std::exception& e) {
20433       {
20434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20435       };
20436     } catch (Dali::DaliException e) {
20437       {
20438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20439       };
20440     } catch (...) {
20441       {
20442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20443       };
20444     }
20445   }
20446
20447   jresult = new Dali::Handle((const Dali::Handle &)result);
20448   return jresult;
20449 }
20450
20451
20452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20453   unsigned int jresult ;
20454   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20455   Dali::Handle::Capability arg2 ;
20456   bool result;
20457
20458   arg1 = (Dali::Handle *)jarg1;
20459   arg2 = (Dali::Handle::Capability)jarg2;
20460   {
20461     try {
20462       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20463     } catch (std::out_of_range& e) {
20464       {
20465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20466       };
20467     } catch (std::exception& e) {
20468       {
20469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20470       };
20471     } catch (Dali::DaliException e) {
20472       {
20473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20474       };
20475     } catch (...) {
20476       {
20477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20478       };
20479     }
20480   }
20481
20482   jresult = result;
20483   return jresult;
20484 }
20485
20486
20487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20488   unsigned int jresult ;
20489   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20490   unsigned int result;
20491
20492   arg1 = (Dali::Handle *)jarg1;
20493   {
20494     try {
20495       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
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 char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20521   char * jresult ;
20522   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20523   Dali::Property::Index arg2 ;
20524   std::string result;
20525
20526   arg1 = (Dali::Handle *)jarg1;
20527   arg2 = (Dali::Property::Index)jarg2;
20528   {
20529     try {
20530       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20531     } catch (std::out_of_range& e) {
20532       {
20533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20534       };
20535     } catch (std::exception& e) {
20536       {
20537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20538       };
20539     } catch (Dali::DaliException e) {
20540       {
20541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20542       };
20543     } catch (...) {
20544       {
20545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20546       };
20547     }
20548   }
20549
20550   jresult = SWIG_csharp_string_callback((&result)->c_str());
20551   return jresult;
20552 }
20553
20554
20555 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20556   int jresult ;
20557   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20558   std::string *arg2 = 0 ;
20559   Dali::Property::Index result;
20560
20561   arg1 = (Dali::Handle *)jarg1;
20562   if (!jarg2) {
20563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20564     return 0;
20565   }
20566   std::string arg2_str(jarg2);
20567   arg2 = &arg2_str;
20568   {
20569     try {
20570       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20571     } catch (std::out_of_range& e) {
20572       {
20573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20574       };
20575     } catch (std::exception& e) {
20576       {
20577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20578       };
20579     } catch (Dali::DaliException e) {
20580       {
20581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20582       };
20583     } catch (...) {
20584       {
20585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20586       };
20587     }
20588   }
20589
20590   jresult = result;
20591
20592   //argout typemap for const std::string&
20593
20594   return jresult;
20595 }
20596
20597
20598 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20599   unsigned int jresult ;
20600   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20601   Dali::Property::Index arg2 ;
20602   bool result;
20603
20604   arg1 = (Dali::Handle *)jarg1;
20605   arg2 = (Dali::Property::Index)jarg2;
20606   {
20607     try {
20608       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20609     } catch (std::out_of_range& e) {
20610       {
20611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20612       };
20613     } catch (std::exception& e) {
20614       {
20615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20616       };
20617     } catch (Dali::DaliException e) {
20618       {
20619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20620       };
20621     } catch (...) {
20622       {
20623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20624       };
20625     }
20626   }
20627
20628   jresult = result;
20629   return jresult;
20630 }
20631
20632
20633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20634   unsigned int jresult ;
20635   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20636   Dali::Property::Index arg2 ;
20637   bool result;
20638
20639   arg1 = (Dali::Handle *)jarg1;
20640   arg2 = (Dali::Property::Index)jarg2;
20641   {
20642     try {
20643       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20644     } catch (std::out_of_range& e) {
20645       {
20646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20647       };
20648     } catch (std::exception& e) {
20649       {
20650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20651       };
20652     } catch (Dali::DaliException e) {
20653       {
20654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20655       };
20656     } catch (...) {
20657       {
20658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20659       };
20660     }
20661   }
20662
20663   jresult = result;
20664   return jresult;
20665 }
20666
20667
20668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20669   unsigned int jresult ;
20670   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20671   Dali::Property::Index arg2 ;
20672   bool result;
20673
20674   arg1 = (Dali::Handle *)jarg1;
20675   arg2 = (Dali::Property::Index)jarg2;
20676   {
20677     try {
20678       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20679     } catch (std::out_of_range& e) {
20680       {
20681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20682       };
20683     } catch (std::exception& e) {
20684       {
20685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20686       };
20687     } catch (Dali::DaliException e) {
20688       {
20689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20690       };
20691     } catch (...) {
20692       {
20693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20694       };
20695     }
20696   }
20697
20698   jresult = result;
20699   return jresult;
20700 }
20701
20702
20703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20704   int jresult ;
20705   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20706   Dali::Property::Index arg2 ;
20707   Dali::Property::Type result;
20708
20709   arg1 = (Dali::Handle *)jarg1;
20710   arg2 = (Dali::Property::Index)jarg2;
20711   {
20712     try {
20713       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20714     } catch (std::out_of_range& e) {
20715       {
20716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20717       };
20718     } catch (std::exception& e) {
20719       {
20720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20721       };
20722     } catch (Dali::DaliException e) {
20723       {
20724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20725       };
20726     } catch (...) {
20727       {
20728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20729       };
20730     }
20731   }
20732
20733   jresult = (int)result;
20734   return jresult;
20735 }
20736
20737
20738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20739   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20740   Dali::Property::Index arg2 ;
20741   Dali::Property::Value *arg3 = 0 ;
20742
20743   arg1 = (Dali::Handle *)jarg1;
20744   arg2 = (Dali::Property::Index)jarg2;
20745   arg3 = (Dali::Property::Value *)jarg3;
20746   if (!arg3) {
20747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20748     return ;
20749   }
20750   {
20751     try {
20752       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20753     } catch (std::out_of_range& e) {
20754       {
20755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20756       };
20757     } catch (std::exception& e) {
20758       {
20759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20760       };
20761     } catch (Dali::DaliException e) {
20762       {
20763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20764       };
20765     } catch (...) {
20766       {
20767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20768       };
20769     }
20770   }
20771
20772 }
20773
20774
20775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20776   int jresult ;
20777   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20778   std::string *arg2 = 0 ;
20779   Dali::Property::Value *arg3 = 0 ;
20780   Dali::Property::Index result;
20781
20782   arg1 = (Dali::Handle *)jarg1;
20783   if (!jarg2) {
20784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20785     return 0;
20786   }
20787   std::string arg2_str(jarg2);
20788   arg2 = &arg2_str;
20789   arg3 = (Dali::Property::Value *)jarg3;
20790   if (!arg3) {
20791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20792     return 0;
20793   }
20794   {
20795     try {
20796       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20797     } catch (std::out_of_range& e) {
20798       {
20799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20800       };
20801     } catch (std::exception& e) {
20802       {
20803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20804       };
20805     } catch (Dali::DaliException e) {
20806       {
20807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20808       };
20809     } catch (...) {
20810       {
20811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20812       };
20813     }
20814   }
20815
20816   jresult = result;
20817
20818   //argout typemap for const std::string&
20819
20820   return jresult;
20821 }
20822
20823
20824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20825   int jresult ;
20826   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20827   std::string *arg2 = 0 ;
20828   Dali::Property::Value *arg3 = 0 ;
20829   Dali::Property::AccessMode arg4 ;
20830   Dali::Property::Index result;
20831
20832   arg1 = (Dali::Handle *)jarg1;
20833   if (!jarg2) {
20834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20835     return 0;
20836   }
20837   std::string arg2_str(jarg2);
20838   arg2 = &arg2_str;
20839   arg3 = (Dali::Property::Value *)jarg3;
20840   if (!arg3) {
20841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20842     return 0;
20843   }
20844   arg4 = (Dali::Property::AccessMode)jarg4;
20845   {
20846     try {
20847       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20848     } catch (std::out_of_range& e) {
20849       {
20850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20851       };
20852     } catch (std::exception& e) {
20853       {
20854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20855       };
20856     } catch (Dali::DaliException e) {
20857       {
20858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20859       };
20860     } catch (...) {
20861       {
20862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20863       };
20864     }
20865   }
20866
20867   jresult = result;
20868
20869   //argout typemap for const std::string&
20870
20871   return jresult;
20872 }
20873
20874
20875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20876   void * jresult ;
20877   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20878   Dali::Property::Index arg2 ;
20879   Dali::Property::Value result;
20880
20881   arg1 = (Dali::Handle *)jarg1;
20882   arg2 = (Dali::Property::Index)jarg2;
20883   {
20884     try {
20885       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20886     } catch (std::out_of_range& e) {
20887       {
20888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20889       };
20890     } catch (std::exception& e) {
20891       {
20892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20893       };
20894     } catch (Dali::DaliException e) {
20895       {
20896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20897       };
20898     } catch (...) {
20899       {
20900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20901       };
20902     }
20903   }
20904
20905   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20906   return jresult;
20907 }
20908
20909
20910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20911   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20912   Dali::Property::IndexContainer *arg2 = 0 ;
20913
20914   arg1 = (Dali::Handle *)jarg1;
20915   arg2 = (Dali::Property::IndexContainer *)jarg2;
20916   if (!arg2) {
20917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20918     return ;
20919   }
20920   {
20921     try {
20922       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20923     } catch (std::out_of_range& e) {
20924       {
20925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20926       };
20927     } catch (std::exception& e) {
20928       {
20929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20930       };
20931     } catch (Dali::DaliException e) {
20932       {
20933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20934       };
20935     } catch (...) {
20936       {
20937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20938       };
20939     }
20940   }
20941
20942 }
20943
20944
20945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20946   void * jresult ;
20947   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20948   Dali::Property::Index arg2 ;
20949   Dali::PropertyCondition *arg3 = 0 ;
20950   Dali::PropertyNotification result;
20951
20952   arg1 = (Dali::Handle *)jarg1;
20953   arg2 = (Dali::Property::Index)jarg2;
20954   arg3 = (Dali::PropertyCondition *)jarg3;
20955   if (!arg3) {
20956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20957     return 0;
20958   }
20959   {
20960     try {
20961       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20962     } catch (std::out_of_range& e) {
20963       {
20964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20965       };
20966     } catch (std::exception& e) {
20967       {
20968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20969       };
20970     } catch (Dali::DaliException e) {
20971       {
20972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20973       };
20974     } catch (...) {
20975       {
20976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20977       };
20978     }
20979   }
20980
20981   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20982   return jresult;
20983 }
20984
20985
20986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20987   void * jresult ;
20988   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20989   Dali::Property::Index arg2 ;
20990   int arg3 ;
20991   Dali::PropertyCondition *arg4 = 0 ;
20992   Dali::PropertyNotification result;
20993
20994   arg1 = (Dali::Handle *)jarg1;
20995   arg2 = (Dali::Property::Index)jarg2;
20996   arg3 = (int)jarg3;
20997   arg4 = (Dali::PropertyCondition *)jarg4;
20998   if (!arg4) {
20999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21000     return 0;
21001   }
21002   {
21003     try {
21004       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
21005     } catch (std::out_of_range& e) {
21006       {
21007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21008       };
21009     } catch (std::exception& e) {
21010       {
21011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21012       };
21013     } catch (Dali::DaliException e) {
21014       {
21015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21016       };
21017     } catch (...) {
21018       {
21019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21020       };
21021     }
21022   }
21023
21024   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21025   return jresult;
21026 }
21027
21028
21029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21030   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21031   Dali::PropertyNotification arg2 ;
21032   Dali::PropertyNotification *argp2 ;
21033
21034   arg1 = (Dali::Handle *)jarg1;
21035   argp2 = (Dali::PropertyNotification *)jarg2;
21036   if (!argp2) {
21037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21038     return ;
21039   }
21040   arg2 = *argp2;
21041   {
21042     try {
21043       (arg1)->RemovePropertyNotification(arg2);
21044     } catch (std::out_of_range& e) {
21045       {
21046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21047       };
21048     } catch (std::exception& e) {
21049       {
21050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21051       };
21052     } catch (Dali::DaliException e) {
21053       {
21054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21055       };
21056     } catch (...) {
21057       {
21058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21059       };
21060     }
21061   }
21062
21063 }
21064
21065
21066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21067   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21068
21069   arg1 = (Dali::Handle *)jarg1;
21070   {
21071     try {
21072       (arg1)->RemovePropertyNotifications();
21073     } catch (std::out_of_range& e) {
21074       {
21075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21076       };
21077     } catch (std::exception& e) {
21078       {
21079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21080       };
21081     } catch (Dali::DaliException e) {
21082       {
21083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21084       };
21085     } catch (...) {
21086       {
21087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21088       };
21089     }
21090   }
21091
21092 }
21093
21094
21095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21096   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21097
21098   arg1 = (Dali::Handle *)jarg1;
21099   {
21100     try {
21101       (arg1)->RemoveConstraints();
21102     } catch (std::out_of_range& e) {
21103       {
21104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21105       };
21106     } catch (std::exception& e) {
21107       {
21108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21109       };
21110     } catch (Dali::DaliException e) {
21111       {
21112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21113       };
21114     } catch (...) {
21115       {
21116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21117       };
21118     }
21119   }
21120
21121 }
21122
21123
21124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21125   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21126   unsigned int arg2 ;
21127
21128   arg1 = (Dali::Handle *)jarg1;
21129   arg2 = (unsigned int)jarg2;
21130   {
21131     try {
21132       (arg1)->RemoveConstraints(arg2);
21133     } catch (std::out_of_range& e) {
21134       {
21135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21136       };
21137     } catch (std::exception& e) {
21138       {
21139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21140       };
21141     } catch (Dali::DaliException e) {
21142       {
21143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21144       };
21145     } catch (...) {
21146       {
21147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21148       };
21149     }
21150   }
21151
21152 }
21153
21154
21155 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21156   int jresult ;
21157   Dali::Property::Index result;
21158
21159   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21160   jresult = result;
21161   return jresult;
21162 }
21163
21164
21165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21166   void * jresult ;
21167   Dali::Handle result;
21168
21169   {
21170     try {
21171       result = Dali::WeightObject::New();
21172     } catch (std::out_of_range& e) {
21173       {
21174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21175       };
21176     } catch (std::exception& e) {
21177       {
21178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21179       };
21180     } catch (Dali::DaliException e) {
21181       {
21182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21183       };
21184     } catch (...) {
21185       {
21186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21187       };
21188     }
21189   }
21190
21191   jresult = new Dali::Handle((const Dali::Handle &)result);
21192   return jresult;
21193 }
21194
21195
21196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21197   void * jresult ;
21198   Dali::TypeInfo *result = 0 ;
21199
21200   {
21201     try {
21202       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21203     } catch (std::out_of_range& e) {
21204       {
21205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21206       };
21207     } catch (std::exception& e) {
21208       {
21209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21210       };
21211     } catch (Dali::DaliException e) {
21212       {
21213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21214       };
21215     } catch (...) {
21216       {
21217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21218       };
21219     }
21220   }
21221
21222   jresult = (void *)result;
21223   return jresult;
21224 }
21225
21226
21227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21228   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21229
21230   arg1 = (Dali::TypeInfo *)jarg1;
21231   {
21232     try {
21233       delete arg1;
21234     } catch (std::out_of_range& e) {
21235       {
21236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21237       };
21238     } catch (std::exception& e) {
21239       {
21240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21241       };
21242     } catch (Dali::DaliException e) {
21243       {
21244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21245       };
21246     } catch (...) {
21247       {
21248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21249       };
21250     }
21251   }
21252
21253 }
21254
21255
21256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21257   void * jresult ;
21258   Dali::TypeInfo *arg1 = 0 ;
21259   Dali::TypeInfo *result = 0 ;
21260
21261   arg1 = (Dali::TypeInfo *)jarg1;
21262   if (!arg1) {
21263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21264     return 0;
21265   }
21266   {
21267     try {
21268       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21269     } catch (std::out_of_range& e) {
21270       {
21271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21272       };
21273     } catch (std::exception& e) {
21274       {
21275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21276       };
21277     } catch (Dali::DaliException e) {
21278       {
21279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21280       };
21281     } catch (...) {
21282       {
21283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21284       };
21285     }
21286   }
21287
21288   jresult = (void *)result;
21289   return jresult;
21290 }
21291
21292
21293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21294   void * jresult ;
21295   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21296   Dali::TypeInfo *arg2 = 0 ;
21297   Dali::TypeInfo *result = 0 ;
21298
21299   arg1 = (Dali::TypeInfo *)jarg1;
21300   arg2 = (Dali::TypeInfo *)jarg2;
21301   if (!arg2) {
21302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21303     return 0;
21304   }
21305   {
21306     try {
21307       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21308     } catch (std::out_of_range& e) {
21309       {
21310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21311       };
21312     } catch (std::exception& e) {
21313       {
21314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21315       };
21316     } catch (Dali::DaliException e) {
21317       {
21318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21319       };
21320     } catch (...) {
21321       {
21322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21323       };
21324     }
21325   }
21326
21327   jresult = (void *)result;
21328   return jresult;
21329 }
21330
21331
21332 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21333   char * jresult ;
21334   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21335   std::string *result = 0 ;
21336
21337   arg1 = (Dali::TypeInfo *)jarg1;
21338   {
21339     try {
21340       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
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 = SWIG_csharp_string_callback(result->c_str());
21361   return jresult;
21362 }
21363
21364
21365 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(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)->GetBaseName();
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 void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21399   void * jresult ;
21400   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21401   Dali::BaseHandle result;
21402
21403   arg1 = (Dali::TypeInfo *)jarg1;
21404   {
21405     try {
21406       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
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 = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21427   return jresult;
21428 }
21429
21430
21431 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21432   unsigned long jresult ;
21433   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21434   size_t result;
21435
21436   arg1 = (Dali::TypeInfo *)jarg1;
21437   {
21438     try {
21439       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
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 = (unsigned long)result;
21460   return jresult;
21461 }
21462
21463
21464 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21465   char * jresult ;
21466   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21467   size_t arg2 ;
21468   std::string result;
21469
21470   arg1 = (Dali::TypeInfo *)jarg1;
21471   arg2 = (size_t)jarg2;
21472   {
21473     try {
21474       result = (arg1)->GetActionName(arg2);
21475     } catch (std::out_of_range& e) {
21476       {
21477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21478       };
21479     } catch (std::exception& e) {
21480       {
21481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21482       };
21483     } catch (Dali::DaliException e) {
21484       {
21485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21486       };
21487     } catch (...) {
21488       {
21489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21490       };
21491     }
21492   }
21493
21494   jresult = SWIG_csharp_string_callback((&result)->c_str());
21495   return jresult;
21496 }
21497
21498
21499 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21500   unsigned long jresult ;
21501   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21502   size_t result;
21503
21504   arg1 = (Dali::TypeInfo *)jarg1;
21505   {
21506     try {
21507       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
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 = (unsigned long)result;
21528   return jresult;
21529 }
21530
21531
21532 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21533   char * jresult ;
21534   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21535   size_t arg2 ;
21536   std::string result;
21537
21538   arg1 = (Dali::TypeInfo *)jarg1;
21539   arg2 = (size_t)jarg2;
21540   {
21541     try {
21542       result = (arg1)->GetSignalName(arg2);
21543     } catch (std::out_of_range& e) {
21544       {
21545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21546       };
21547     } catch (std::exception& e) {
21548       {
21549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21550       };
21551     } catch (Dali::DaliException e) {
21552       {
21553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21554       };
21555     } catch (...) {
21556       {
21557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21558       };
21559     }
21560   }
21561
21562   jresult = SWIG_csharp_string_callback((&result)->c_str());
21563   return jresult;
21564 }
21565
21566
21567 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21568   unsigned long jresult ;
21569   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21570   size_t result;
21571
21572   arg1 = (Dali::TypeInfo *)jarg1;
21573   {
21574     try {
21575       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
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 = (unsigned long)result;
21596   return jresult;
21597 }
21598
21599
21600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21601   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21602   Dali::Property::IndexContainer *arg2 = 0 ;
21603
21604   arg1 = (Dali::TypeInfo *)jarg1;
21605   arg2 = (Dali::Property::IndexContainer *)jarg2;
21606   if (!arg2) {
21607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21608     return ;
21609   }
21610   {
21611     try {
21612       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21613     } catch (std::out_of_range& e) {
21614       {
21615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21616       };
21617     } catch (std::exception& e) {
21618       {
21619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21620       };
21621     } catch (Dali::DaliException e) {
21622       {
21623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21624       };
21625     } catch (...) {
21626       {
21627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21628       };
21629     }
21630   }
21631
21632 }
21633
21634
21635 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21636   char * jresult ;
21637   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21638   Dali::Property::Index arg2 ;
21639   std::string *result = 0 ;
21640
21641   arg1 = (Dali::TypeInfo *)jarg1;
21642   arg2 = (Dali::Property::Index)jarg2;
21643   {
21644     try {
21645       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21646     } catch (std::out_of_range& e) {
21647       {
21648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21649       };
21650     } catch (std::exception& e) {
21651       {
21652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21653       };
21654     } catch (Dali::DaliException e) {
21655       {
21656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21657       };
21658     } catch (...) {
21659       {
21660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21661       };
21662     }
21663   }
21664
21665   jresult = SWIG_csharp_string_callback(result->c_str());
21666   return jresult;
21667 }
21668
21669
21670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21671   void * jresult ;
21672   Dali::TypeRegistry result;
21673
21674   {
21675     try {
21676       result = Dali::TypeRegistry::Get();
21677     } catch (std::out_of_range& e) {
21678       {
21679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21680       };
21681     } catch (std::exception& e) {
21682       {
21683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21684       };
21685     } catch (Dali::DaliException e) {
21686       {
21687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21688       };
21689     } catch (...) {
21690       {
21691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21692       };
21693     }
21694   }
21695
21696   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21697   return jresult;
21698 }
21699
21700
21701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21702   void * jresult ;
21703   Dali::TypeRegistry *result = 0 ;
21704
21705   {
21706     try {
21707       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21708     } catch (std::out_of_range& e) {
21709       {
21710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21711       };
21712     } catch (std::exception& e) {
21713       {
21714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21715       };
21716     } catch (Dali::DaliException e) {
21717       {
21718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21719       };
21720     } catch (...) {
21721       {
21722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21723       };
21724     }
21725   }
21726
21727   jresult = (void *)result;
21728   return jresult;
21729 }
21730
21731
21732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21733   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21734
21735   arg1 = (Dali::TypeRegistry *)jarg1;
21736   {
21737     try {
21738       delete arg1;
21739     } catch (std::out_of_range& e) {
21740       {
21741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21742       };
21743     } catch (std::exception& e) {
21744       {
21745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21746       };
21747     } catch (Dali::DaliException e) {
21748       {
21749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21750       };
21751     } catch (...) {
21752       {
21753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21754       };
21755     }
21756   }
21757
21758 }
21759
21760
21761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21762   void * jresult ;
21763   Dali::TypeRegistry *arg1 = 0 ;
21764   Dali::TypeRegistry *result = 0 ;
21765
21766   arg1 = (Dali::TypeRegistry *)jarg1;
21767   if (!arg1) {
21768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21769     return 0;
21770   }
21771   {
21772     try {
21773       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21774     } catch (std::out_of_range& e) {
21775       {
21776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21777       };
21778     } catch (std::exception& e) {
21779       {
21780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21781       };
21782     } catch (Dali::DaliException e) {
21783       {
21784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21785       };
21786     } catch (...) {
21787       {
21788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21789       };
21790     }
21791   }
21792
21793   jresult = (void *)result;
21794   return jresult;
21795 }
21796
21797
21798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21799   void * jresult ;
21800   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21801   Dali::TypeRegistry *arg2 = 0 ;
21802   Dali::TypeRegistry *result = 0 ;
21803
21804   arg1 = (Dali::TypeRegistry *)jarg1;
21805   arg2 = (Dali::TypeRegistry *)jarg2;
21806   if (!arg2) {
21807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21808     return 0;
21809   }
21810   {
21811     try {
21812       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21813     } catch (std::out_of_range& e) {
21814       {
21815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21816       };
21817     } catch (std::exception& e) {
21818       {
21819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21820       };
21821     } catch (Dali::DaliException e) {
21822       {
21823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21824       };
21825     } catch (...) {
21826       {
21827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21828       };
21829     }
21830   }
21831
21832   jresult = (void *)result;
21833   return jresult;
21834 }
21835
21836
21837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21838   void * jresult ;
21839   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21840   std::string *arg2 = 0 ;
21841   Dali::TypeInfo result;
21842
21843   arg1 = (Dali::TypeRegistry *)jarg1;
21844   if (!jarg2) {
21845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21846     return 0;
21847   }
21848   std::string arg2_str(jarg2);
21849   arg2 = &arg2_str;
21850   {
21851     try {
21852       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21853     } catch (std::out_of_range& e) {
21854       {
21855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21856       };
21857     } catch (std::exception& e) {
21858       {
21859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21860       };
21861     } catch (Dali::DaliException e) {
21862       {
21863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21864       };
21865     } catch (...) {
21866       {
21867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21868       };
21869     }
21870   }
21871
21872   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21873
21874   //argout typemap for const std::string&
21875
21876   return jresult;
21877 }
21878
21879
21880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21881   void * jresult ;
21882   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21883   std::type_info *arg2 = 0 ;
21884   Dali::TypeInfo result;
21885
21886   arg1 = (Dali::TypeRegistry *)jarg1;
21887   arg2 = (std::type_info *)jarg2;
21888   if (!arg2) {
21889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21890     return 0;
21891   }
21892   {
21893     try {
21894       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21895     } catch (std::out_of_range& e) {
21896       {
21897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21898       };
21899     } catch (std::exception& e) {
21900       {
21901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21902       };
21903     } catch (Dali::DaliException e) {
21904       {
21905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21906       };
21907     } catch (...) {
21908       {
21909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21910       };
21911     }
21912   }
21913
21914   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21915   return jresult;
21916 }
21917
21918
21919 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21920   unsigned long jresult ;
21921   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21922   size_t result;
21923
21924   arg1 = (Dali::TypeRegistry *)jarg1;
21925   {
21926     try {
21927       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
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 = (unsigned long)result;
21948   return jresult;
21949 }
21950
21951
21952 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21953   char * jresult ;
21954   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21955   size_t arg2 ;
21956   std::string result;
21957
21958   arg1 = (Dali::TypeRegistry *)jarg1;
21959   arg2 = (size_t)jarg2;
21960   {
21961     try {
21962       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21963     } catch (std::out_of_range& e) {
21964       {
21965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21966       };
21967     } catch (std::exception& e) {
21968       {
21969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21970       };
21971     } catch (Dali::DaliException e) {
21972       {
21973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21974       };
21975     } catch (...) {
21976       {
21977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21978       };
21979     }
21980   }
21981
21982   jresult = SWIG_csharp_string_callback((&result)->c_str());
21983   return jresult;
21984 }
21985
21986
21987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21988   void * jresult ;
21989   std::type_info *arg1 = 0 ;
21990   std::type_info *arg2 = 0 ;
21991   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21992   Dali::TypeRegistration *result = 0 ;
21993
21994   arg1 = (std::type_info *)jarg1;
21995   if (!arg1) {
21996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21997     return 0;
21998   }
21999   arg2 = (std::type_info *)jarg2;
22000   if (!arg2) {
22001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22002     return 0;
22003   }
22004   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22005   {
22006     try {
22007       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22008     } catch (std::out_of_range& e) {
22009       {
22010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22011       };
22012     } catch (std::exception& e) {
22013       {
22014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22015       };
22016     } catch (Dali::DaliException e) {
22017       {
22018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22019       };
22020     } catch (...) {
22021       {
22022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22023       };
22024     }
22025   }
22026
22027   jresult = (void *)result;
22028   return jresult;
22029 }
22030
22031
22032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22033   void * jresult ;
22034   std::type_info *arg1 = 0 ;
22035   std::type_info *arg2 = 0 ;
22036   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22037   bool arg4 ;
22038   Dali::TypeRegistration *result = 0 ;
22039
22040   arg1 = (std::type_info *)jarg1;
22041   if (!arg1) {
22042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22043     return 0;
22044   }
22045   arg2 = (std::type_info *)jarg2;
22046   if (!arg2) {
22047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22048     return 0;
22049   }
22050   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22051   arg4 = jarg4 ? true : false;
22052   {
22053     try {
22054       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22055     } catch (std::out_of_range& e) {
22056       {
22057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22058       };
22059     } catch (std::exception& e) {
22060       {
22061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22062       };
22063     } catch (Dali::DaliException e) {
22064       {
22065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22066       };
22067     } catch (...) {
22068       {
22069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22070       };
22071     }
22072   }
22073
22074   jresult = (void *)result;
22075   return jresult;
22076 }
22077
22078
22079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22080   void * jresult ;
22081   std::string *arg1 = 0 ;
22082   std::type_info *arg2 = 0 ;
22083   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22084   Dali::TypeRegistration *result = 0 ;
22085
22086   if (!jarg1) {
22087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22088     return 0;
22089   }
22090   std::string arg1_str(jarg1);
22091   arg1 = &arg1_str;
22092   arg2 = (std::type_info *)jarg2;
22093   if (!arg2) {
22094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22095     return 0;
22096   }
22097   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22098   {
22099     try {
22100       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22101     } catch (std::out_of_range& e) {
22102       {
22103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22104       };
22105     } catch (std::exception& e) {
22106       {
22107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22108       };
22109     } catch (Dali::DaliException e) {
22110       {
22111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22112       };
22113     } catch (...) {
22114       {
22115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22116       };
22117     }
22118   }
22119
22120   jresult = (void *)result;
22121
22122   //argout typemap for const std::string&
22123
22124   return jresult;
22125 }
22126
22127
22128 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22129   char * jresult ;
22130   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22131   std::string result;
22132
22133   arg1 = (Dali::TypeRegistration *)jarg1;
22134   {
22135     try {
22136       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22137     } catch (std::out_of_range& e) {
22138       {
22139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22140       };
22141     } catch (std::exception& e) {
22142       {
22143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22144       };
22145     } catch (Dali::DaliException e) {
22146       {
22147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22148       };
22149     } catch (...) {
22150       {
22151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22152       };
22153     }
22154   }
22155
22156   jresult = SWIG_csharp_string_callback((&result)->c_str());
22157   return jresult;
22158 }
22159
22160
22161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22162   std::string *arg1 = 0 ;
22163   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22164
22165   if (!jarg1) {
22166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22167     return ;
22168   }
22169   std::string arg1_str(jarg1);
22170   arg1 = &arg1_str;
22171   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22172   {
22173     try {
22174       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22175     } catch (std::out_of_range& e) {
22176       {
22177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22178       };
22179     } catch (std::exception& e) {
22180       {
22181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22182       };
22183     } catch (Dali::DaliException e) {
22184       {
22185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22186       };
22187     } catch (...) {
22188       {
22189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22190       };
22191     }
22192   }
22193
22194
22195   //argout typemap for const std::string&
22196
22197 }
22198
22199
22200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22201   std::string *arg1 = 0 ;
22202   std::string *arg2 = 0 ;
22203   int arg3 ;
22204   Dali::Property::Type arg4 ;
22205   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22206   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22207
22208   if (!jarg1) {
22209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22210     return ;
22211   }
22212   std::string arg1_str(jarg1);
22213   arg1 = &arg1_str;
22214   if (!jarg2) {
22215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22216     return ;
22217   }
22218   std::string arg2_str(jarg2);
22219   arg2 = &arg2_str;
22220   arg3 = (int)jarg3;
22221   arg4 = (Dali::Property::Type)jarg4;
22222   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22223   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22224   {
22225     try {
22226       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22227     } catch (std::out_of_range& e) {
22228       {
22229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22230       };
22231     } catch (std::exception& e) {
22232       {
22233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22234       };
22235     } catch (Dali::DaliException e) {
22236       {
22237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22238       };
22239     } catch (...) {
22240       {
22241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22242       };
22243     }
22244   }
22245
22246
22247   //argout typemap for const std::string&
22248
22249
22250   //argout typemap for const std::string&
22251
22252 }
22253
22254
22255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22256   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22257
22258   arg1 = (Dali::TypeRegistration *)jarg1;
22259   {
22260     try {
22261       delete arg1;
22262     } catch (std::out_of_range& e) {
22263       {
22264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22265       };
22266     } catch (std::exception& e) {
22267       {
22268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22269       };
22270     } catch (Dali::DaliException e) {
22271       {
22272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22273       };
22274     } catch (...) {
22275       {
22276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22277       };
22278     }
22279   }
22280
22281 }
22282
22283
22284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22285   void * jresult ;
22286   Dali::TypeRegistration *arg1 = 0 ;
22287   std::string *arg2 = 0 ;
22288   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22289   Dali::SignalConnectorType *result = 0 ;
22290
22291   arg1 = (Dali::TypeRegistration *)jarg1;
22292   if (!arg1) {
22293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22294     return 0;
22295   }
22296   if (!jarg2) {
22297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22298     return 0;
22299   }
22300   std::string arg2_str(jarg2);
22301   arg2 = &arg2_str;
22302   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22303   {
22304     try {
22305       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22306     } catch (std::out_of_range& e) {
22307       {
22308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22309       };
22310     } catch (std::exception& e) {
22311       {
22312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22313       };
22314     } catch (Dali::DaliException e) {
22315       {
22316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22317       };
22318     } catch (...) {
22319       {
22320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22321       };
22322     }
22323   }
22324
22325   jresult = (void *)result;
22326
22327   //argout typemap for const std::string&
22328
22329   return jresult;
22330 }
22331
22332
22333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22334   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22335
22336   arg1 = (Dali::SignalConnectorType *)jarg1;
22337   {
22338     try {
22339       delete arg1;
22340     } catch (std::out_of_range& e) {
22341       {
22342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22343       };
22344     } catch (std::exception& e) {
22345       {
22346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22347       };
22348     } catch (Dali::DaliException e) {
22349       {
22350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22351       };
22352     } catch (...) {
22353       {
22354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22355       };
22356     }
22357   }
22358
22359 }
22360
22361
22362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22363   void * jresult ;
22364   Dali::TypeRegistration *arg1 = 0 ;
22365   std::string *arg2 = 0 ;
22366   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22367   Dali::TypeAction *result = 0 ;
22368
22369   arg1 = (Dali::TypeRegistration *)jarg1;
22370   if (!arg1) {
22371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22372     return 0;
22373   }
22374   if (!jarg2) {
22375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22376     return 0;
22377   }
22378   std::string arg2_str(jarg2);
22379   arg2 = &arg2_str;
22380   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22381   {
22382     try {
22383       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22384     } catch (std::out_of_range& e) {
22385       {
22386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22387       };
22388     } catch (std::exception& e) {
22389       {
22390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22391       };
22392     } catch (Dali::DaliException e) {
22393       {
22394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22395       };
22396     } catch (...) {
22397       {
22398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22399       };
22400     }
22401   }
22402
22403   jresult = (void *)result;
22404
22405   //argout typemap for const std::string&
22406
22407   return jresult;
22408 }
22409
22410
22411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22412   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22413
22414   arg1 = (Dali::TypeAction *)jarg1;
22415   {
22416     try {
22417       delete arg1;
22418     } catch (std::out_of_range& e) {
22419       {
22420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22421       };
22422     } catch (std::exception& e) {
22423       {
22424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22425       };
22426     } catch (Dali::DaliException e) {
22427       {
22428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22429       };
22430     } catch (...) {
22431       {
22432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22433       };
22434     }
22435   }
22436
22437 }
22438
22439
22440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22441   void * jresult ;
22442   Dali::TypeRegistration *arg1 = 0 ;
22443   std::string *arg2 = 0 ;
22444   Dali::Property::Index arg3 ;
22445   Dali::Property::Type arg4 ;
22446   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22447   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22448   Dali::PropertyRegistration *result = 0 ;
22449
22450   arg1 = (Dali::TypeRegistration *)jarg1;
22451   if (!arg1) {
22452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22453     return 0;
22454   }
22455   if (!jarg2) {
22456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22457     return 0;
22458   }
22459   std::string arg2_str(jarg2);
22460   arg2 = &arg2_str;
22461   arg3 = (Dali::Property::Index)jarg3;
22462   arg4 = (Dali::Property::Type)jarg4;
22463   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22464   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22465   {
22466     try {
22467       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22468     } catch (std::out_of_range& e) {
22469       {
22470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22471       };
22472     } catch (std::exception& e) {
22473       {
22474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22475       };
22476     } catch (Dali::DaliException e) {
22477       {
22478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22479       };
22480     } catch (...) {
22481       {
22482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22483       };
22484     }
22485   }
22486
22487   jresult = (void *)result;
22488
22489   //argout typemap for const std::string&
22490
22491   return jresult;
22492 }
22493
22494
22495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22496   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22497
22498   arg1 = (Dali::PropertyRegistration *)jarg1;
22499   {
22500     try {
22501       delete arg1;
22502     } catch (std::out_of_range& e) {
22503       {
22504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22505       };
22506     } catch (std::exception& e) {
22507       {
22508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22509       };
22510     } catch (Dali::DaliException e) {
22511       {
22512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22513       };
22514     } catch (...) {
22515       {
22516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22517       };
22518     }
22519   }
22520
22521 }
22522
22523
22524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22525   void * jresult ;
22526   Dali::TypeRegistration *arg1 = 0 ;
22527   std::string *arg2 = 0 ;
22528   Dali::Property::Index arg3 ;
22529   Dali::Property::Type arg4 ;
22530   Dali::AnimatablePropertyRegistration *result = 0 ;
22531
22532   arg1 = (Dali::TypeRegistration *)jarg1;
22533   if (!arg1) {
22534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22535     return 0;
22536   }
22537   if (!jarg2) {
22538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22539     return 0;
22540   }
22541   std::string arg2_str(jarg2);
22542   arg2 = &arg2_str;
22543   arg3 = (Dali::Property::Index)jarg3;
22544   arg4 = (Dali::Property::Type)jarg4;
22545   {
22546     try {
22547       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22548     } catch (std::out_of_range& e) {
22549       {
22550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22551       };
22552     } catch (std::exception& e) {
22553       {
22554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22555       };
22556     } catch (Dali::DaliException e) {
22557       {
22558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22559       };
22560     } catch (...) {
22561       {
22562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22563       };
22564     }
22565   }
22566
22567   jresult = (void *)result;
22568
22569   //argout typemap for const std::string&
22570
22571   return jresult;
22572 }
22573
22574
22575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22576   void * jresult ;
22577   Dali::TypeRegistration *arg1 = 0 ;
22578   std::string *arg2 = 0 ;
22579   Dali::Property::Index arg3 ;
22580   Dali::Property::Value *arg4 = 0 ;
22581   Dali::AnimatablePropertyRegistration *result = 0 ;
22582
22583   arg1 = (Dali::TypeRegistration *)jarg1;
22584   if (!arg1) {
22585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22586     return 0;
22587   }
22588   if (!jarg2) {
22589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22590     return 0;
22591   }
22592   std::string arg2_str(jarg2);
22593   arg2 = &arg2_str;
22594   arg3 = (Dali::Property::Index)jarg3;
22595   arg4 = (Dali::Property::Value *)jarg4;
22596   if (!arg4) {
22597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22598     return 0;
22599   }
22600   {
22601     try {
22602       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22603     } catch (std::out_of_range& e) {
22604       {
22605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22606       };
22607     } catch (std::exception& e) {
22608       {
22609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22610       };
22611     } catch (Dali::DaliException e) {
22612       {
22613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22614       };
22615     } catch (...) {
22616       {
22617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22618       };
22619     }
22620   }
22621
22622   jresult = (void *)result;
22623
22624   //argout typemap for const std::string&
22625
22626   return jresult;
22627 }
22628
22629
22630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22631   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22632
22633   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22634   {
22635     try {
22636       delete arg1;
22637     } catch (std::out_of_range& e) {
22638       {
22639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22640       };
22641     } catch (std::exception& e) {
22642       {
22643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22644       };
22645     } catch (Dali::DaliException e) {
22646       {
22647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22648       };
22649     } catch (...) {
22650       {
22651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22652       };
22653     }
22654   }
22655
22656 }
22657
22658
22659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22660   void * jresult ;
22661   Dali::TypeRegistration *arg1 = 0 ;
22662   std::string *arg2 = 0 ;
22663   Dali::Property::Index arg3 ;
22664   Dali::Property::Index arg4 ;
22665   unsigned int arg5 ;
22666   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22667
22668   arg1 = (Dali::TypeRegistration *)jarg1;
22669   if (!arg1) {
22670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22671     return 0;
22672   }
22673   if (!jarg2) {
22674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22675     return 0;
22676   }
22677   std::string arg2_str(jarg2);
22678   arg2 = &arg2_str;
22679   arg3 = (Dali::Property::Index)jarg3;
22680   arg4 = (Dali::Property::Index)jarg4;
22681   arg5 = (unsigned int)jarg5;
22682   {
22683     try {
22684       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22685     } catch (std::out_of_range& e) {
22686       {
22687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22688       };
22689     } catch (std::exception& e) {
22690       {
22691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22692       };
22693     } catch (Dali::DaliException e) {
22694       {
22695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22696       };
22697     } catch (...) {
22698       {
22699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22700       };
22701     }
22702   }
22703
22704   jresult = (void *)result;
22705
22706   //argout typemap for const std::string&
22707
22708   return jresult;
22709 }
22710
22711
22712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22713   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22714
22715   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22716   {
22717     try {
22718       delete arg1;
22719     } catch (std::out_of_range& e) {
22720       {
22721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22722       };
22723     } catch (std::exception& e) {
22724       {
22725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22726       };
22727     } catch (Dali::DaliException e) {
22728       {
22729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22730       };
22731     } catch (...) {
22732       {
22733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22734       };
22735     }
22736   }
22737
22738 }
22739
22740
22741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22742   void * jresult ;
22743   Dali::TypeRegistration *arg1 = 0 ;
22744   std::string *arg2 = 0 ;
22745   Dali::Property::Index arg3 ;
22746   Dali::Property::Type arg4 ;
22747   Dali::ChildPropertyRegistration *result = 0 ;
22748
22749   arg1 = (Dali::TypeRegistration *)jarg1;
22750   if (!arg1) {
22751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22752     return 0;
22753   }
22754   if (!jarg2) {
22755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22756     return 0;
22757   }
22758   std::string arg2_str(jarg2);
22759   arg2 = &arg2_str;
22760   arg3 = (Dali::Property::Index)jarg3;
22761   arg4 = (Dali::Property::Type)jarg4;
22762   {
22763     try {
22764       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22765     } catch (std::out_of_range& e) {
22766       {
22767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22768       };
22769     } catch (std::exception& e) {
22770       {
22771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22772       };
22773     } catch (Dali::DaliException e) {
22774       {
22775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22776       };
22777     } catch (...) {
22778       {
22779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22780       };
22781     }
22782   }
22783
22784   jresult = (void *)result;
22785
22786   //argout typemap for const std::string&
22787
22788   return jresult;
22789 }
22790
22791
22792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22793   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22794
22795   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22796   {
22797     try {
22798       delete arg1;
22799     } catch (std::out_of_range& e) {
22800       {
22801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22802       };
22803     } catch (std::exception& e) {
22804       {
22805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22806       };
22807     } catch (Dali::DaliException e) {
22808       {
22809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22810       };
22811     } catch (...) {
22812       {
22813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22814       };
22815     }
22816   }
22817
22818 }
22819
22820
22821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22822   unsigned int jresult ;
22823   std::string *arg1 = 0 ;
22824   std::type_info *arg2 = 0 ;
22825   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22826   bool result;
22827
22828   if (!jarg1) {
22829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22830     return 0;
22831   }
22832   std::string arg1_str(jarg1);
22833   arg1 = &arg1_str;
22834   arg2 = (std::type_info *)jarg2;
22835   if (!arg2) {
22836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22837     return 0;
22838   }
22839   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22840   {
22841     try {
22842       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22843     } catch (std::out_of_range& e) {
22844       {
22845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22846       };
22847     } catch (std::exception& e) {
22848       {
22849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22850       };
22851     } catch (Dali::DaliException e) {
22852       {
22853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22854       };
22855     } catch (...) {
22856       {
22857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22858       };
22859     }
22860   }
22861
22862   jresult = result;
22863
22864   //argout typemap for const std::string&
22865
22866   return jresult;
22867 }
22868
22869
22870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22871   unsigned int jresult ;
22872   std::string *arg1 = 0 ;
22873   std::string *arg2 = 0 ;
22874   Dali::Property::Index arg3 ;
22875   Dali::Property::Type arg4 ;
22876   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22877   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22878   bool result;
22879
22880   if (!jarg1) {
22881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22882     return 0;
22883   }
22884   std::string arg1_str(jarg1);
22885   arg1 = &arg1_str;
22886   if (!jarg2) {
22887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22888     return 0;
22889   }
22890   std::string arg2_str(jarg2);
22891   arg2 = &arg2_str;
22892   arg3 = (Dali::Property::Index)jarg3;
22893   arg4 = (Dali::Property::Type)jarg4;
22894   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22895   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22896   {
22897     try {
22898       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22899     } catch (std::out_of_range& e) {
22900       {
22901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22902       };
22903     } catch (std::exception& e) {
22904       {
22905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22906       };
22907     } catch (Dali::DaliException e) {
22908       {
22909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22910       };
22911     } catch (...) {
22912       {
22913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22914       };
22915     }
22916   }
22917
22918   jresult = result;
22919
22920   //argout typemap for const std::string&
22921
22922
22923   //argout typemap for const std::string&
22924
22925   return jresult;
22926 }
22927
22928
22929 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22930   float jresult ;
22931   float result;
22932
22933   result = (float)(float)Dali::ParentOrigin::TOP;
22934   jresult = result;
22935   return jresult;
22936 }
22937
22938
22939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22940   float jresult ;
22941   float result;
22942
22943   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22944   jresult = result;
22945   return jresult;
22946 }
22947
22948
22949 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22950   float jresult ;
22951   float result;
22952
22953   result = (float)(float)Dali::ParentOrigin::LEFT;
22954   jresult = result;
22955   return jresult;
22956 }
22957
22958
22959 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22960   float jresult ;
22961   float result;
22962
22963   result = (float)(float)Dali::ParentOrigin::RIGHT;
22964   jresult = result;
22965   return jresult;
22966 }
22967
22968
22969 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22970   float jresult ;
22971   float result;
22972
22973   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22974   jresult = result;
22975   return jresult;
22976 }
22977
22978
22979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22980   void * jresult ;
22981   Dali::Vector3 *result = 0 ;
22982
22983   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22984   jresult = (void *)result;
22985   return jresult;
22986 }
22987
22988
22989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22990   void * jresult ;
22991   Dali::Vector3 *result = 0 ;
22992
22993   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22994   jresult = (void *)result;
22995   return jresult;
22996 }
22997
22998
22999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23000   void * jresult ;
23001   Dali::Vector3 *result = 0 ;
23002
23003   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23004   jresult = (void *)result;
23005   return jresult;
23006 }
23007
23008
23009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23010   void * jresult ;
23011   Dali::Vector3 *result = 0 ;
23012
23013   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23014   jresult = (void *)result;
23015   return jresult;
23016 }
23017
23018
23019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23020   void * jresult ;
23021   Dali::Vector3 *result = 0 ;
23022
23023   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23024   jresult = (void *)result;
23025   return jresult;
23026 }
23027
23028
23029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23030   void * jresult ;
23031   Dali::Vector3 *result = 0 ;
23032
23033   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23034   jresult = (void *)result;
23035   return jresult;
23036 }
23037
23038
23039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23040   void * jresult ;
23041   Dali::Vector3 *result = 0 ;
23042
23043   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23044   jresult = (void *)result;
23045   return jresult;
23046 }
23047
23048
23049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23050   void * jresult ;
23051   Dali::Vector3 *result = 0 ;
23052
23053   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23054   jresult = (void *)result;
23055   return jresult;
23056 }
23057
23058
23059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23060   void * jresult ;
23061   Dali::Vector3 *result = 0 ;
23062
23063   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23064   jresult = (void *)result;
23065   return jresult;
23066 }
23067
23068
23069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23070   float jresult ;
23071   float result;
23072
23073   result = (float)(float)Dali::AnchorPoint::TOP;
23074   jresult = result;
23075   return jresult;
23076 }
23077
23078
23079 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23080   float jresult ;
23081   float result;
23082
23083   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23084   jresult = result;
23085   return jresult;
23086 }
23087
23088
23089 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23090   float jresult ;
23091   float result;
23092
23093   result = (float)(float)Dali::AnchorPoint::LEFT;
23094   jresult = result;
23095   return jresult;
23096 }
23097
23098
23099 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23100   float jresult ;
23101   float result;
23102
23103   result = (float)(float)Dali::AnchorPoint::RIGHT;
23104   jresult = result;
23105   return jresult;
23106 }
23107
23108
23109 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23110   float jresult ;
23111   float result;
23112
23113   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23114   jresult = result;
23115   return jresult;
23116 }
23117
23118
23119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23120   void * jresult ;
23121   Dali::Vector3 *result = 0 ;
23122
23123   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23124   jresult = (void *)result;
23125   return jresult;
23126 }
23127
23128
23129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23130   void * jresult ;
23131   Dali::Vector3 *result = 0 ;
23132
23133   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23134   jresult = (void *)result;
23135   return jresult;
23136 }
23137
23138
23139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23140   void * jresult ;
23141   Dali::Vector3 *result = 0 ;
23142
23143   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23144   jresult = (void *)result;
23145   return jresult;
23146 }
23147
23148
23149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23150   void * jresult ;
23151   Dali::Vector3 *result = 0 ;
23152
23153   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23154   jresult = (void *)result;
23155   return jresult;
23156 }
23157
23158
23159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23160   void * jresult ;
23161   Dali::Vector3 *result = 0 ;
23162
23163   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23164   jresult = (void *)result;
23165   return jresult;
23166 }
23167
23168
23169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23170   void * jresult ;
23171   Dali::Vector3 *result = 0 ;
23172
23173   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23174   jresult = (void *)result;
23175   return jresult;
23176 }
23177
23178
23179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23180   void * jresult ;
23181   Dali::Vector3 *result = 0 ;
23182
23183   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23184   jresult = (void *)result;
23185   return jresult;
23186 }
23187
23188
23189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23190   void * jresult ;
23191   Dali::Vector3 *result = 0 ;
23192
23193   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23194   jresult = (void *)result;
23195   return jresult;
23196 }
23197
23198
23199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23200   void * jresult ;
23201   Dali::Vector3 *result = 0 ;
23202
23203   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23204   jresult = (void *)result;
23205   return jresult;
23206 }
23207
23208
23209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23210   void * jresult ;
23211   Dali::Vector4 *result = 0 ;
23212
23213   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23214   jresult = (void *)result;
23215   return jresult;
23216 }
23217
23218
23219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23220   void * jresult ;
23221   Dali::Vector4 *result = 0 ;
23222
23223   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23224   jresult = (void *)result;
23225   return jresult;
23226 }
23227
23228
23229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23230   void * jresult ;
23231   Dali::Vector4 *result = 0 ;
23232
23233   result = (Dali::Vector4 *)&Dali::Color::RED;
23234   jresult = (void *)result;
23235   return jresult;
23236 }
23237
23238
23239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23240   void * jresult ;
23241   Dali::Vector4 *result = 0 ;
23242
23243   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23244   jresult = (void *)result;
23245   return jresult;
23246 }
23247
23248
23249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23250   void * jresult ;
23251   Dali::Vector4 *result = 0 ;
23252
23253   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23254   jresult = (void *)result;
23255   return jresult;
23256 }
23257
23258
23259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23260   void * jresult ;
23261   Dali::Vector4 *result = 0 ;
23262
23263   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23264   jresult = (void *)result;
23265   return jresult;
23266 }
23267
23268
23269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23270   void * jresult ;
23271   Dali::Vector4 *result = 0 ;
23272
23273   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23274   jresult = (void *)result;
23275   return jresult;
23276 }
23277
23278
23279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23280   void * jresult ;
23281   Dali::Vector4 *result = 0 ;
23282
23283   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23284   jresult = (void *)result;
23285   return jresult;
23286 }
23287
23288
23289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23290   void * jresult ;
23291   Dali::Vector4 *result = 0 ;
23292
23293   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23294   jresult = (void *)result;
23295   return jresult;
23296 }
23297
23298
23299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23300   float jresult ;
23301   float result;
23302
23303   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23304   jresult = result;
23305   return jresult;
23306 }
23307
23308
23309 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23310   float jresult ;
23311   float result;
23312
23313   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23314   jresult = result;
23315   return jresult;
23316 }
23317
23318
23319 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23320   float jresult ;
23321   float result;
23322
23323   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23324   jresult = result;
23325   return jresult;
23326 }
23327
23328
23329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23330   float jresult ;
23331   float result;
23332
23333   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23334   jresult = result;
23335   return jresult;
23336 }
23337
23338
23339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23340   float jresult ;
23341   float result;
23342
23343   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23344   jresult = result;
23345   return jresult;
23346 }
23347
23348
23349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23350   float jresult ;
23351   float result;
23352
23353   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23354   jresult = result;
23355   return jresult;
23356 }
23357
23358
23359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23360   float jresult ;
23361   float result;
23362
23363   result = (float)(float)Dali::Math::PI;
23364   jresult = result;
23365   return jresult;
23366 }
23367
23368
23369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23370   float jresult ;
23371   float result;
23372
23373   result = (float)(float)Dali::Math::PI_2;
23374   jresult = result;
23375   return jresult;
23376 }
23377
23378
23379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23380   float jresult ;
23381   float result;
23382
23383   result = (float)(float)Dali::Math::PI_4;
23384   jresult = result;
23385   return jresult;
23386 }
23387
23388
23389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23390   float jresult ;
23391   float result;
23392
23393   result = (float)(float)Dali::Math::PI_OVER_180;
23394   jresult = result;
23395   return jresult;
23396 }
23397
23398
23399 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23400   float jresult ;
23401   float result;
23402
23403   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23404   jresult = result;
23405   return jresult;
23406 }
23407
23408
23409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23410   int jresult ;
23411   Dali::ResizePolicy::Type result;
23412
23413   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23414   jresult = (int)result;
23415   return jresult;
23416 }
23417
23418
23419 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23420   unsigned long jresult ;
23421   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23422   Dali::VectorBase::SizeType result;
23423
23424   arg1 = (Dali::VectorBase *)jarg1;
23425   {
23426     try {
23427       result = ((Dali::VectorBase const *)arg1)->Count();
23428     } catch (std::out_of_range& e) {
23429       {
23430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23431       };
23432     } catch (std::exception& e) {
23433       {
23434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23435       };
23436     } catch (Dali::DaliException e) {
23437       {
23438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23439       };
23440     } catch (...) {
23441       {
23442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23443       };
23444     }
23445   }
23446
23447   jresult = (unsigned long)result;
23448   return jresult;
23449 }
23450
23451
23452 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(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)->Size();
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 int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23486   unsigned int jresult ;
23487   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23488   bool result;
23489
23490   arg1 = (Dali::VectorBase *)jarg1;
23491   {
23492     try {
23493       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
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 = result;
23514   return jresult;
23515 }
23516
23517
23518 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23519   unsigned long jresult ;
23520   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23521   Dali::VectorBase::SizeType result;
23522
23523   arg1 = (Dali::VectorBase *)jarg1;
23524   {
23525     try {
23526       result = ((Dali::VectorBase const *)arg1)->Capacity();
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 = (unsigned long)result;
23547   return jresult;
23548 }
23549
23550
23551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23552   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23553
23554   arg1 = (Dali::VectorBase *)jarg1;
23555   {
23556     try {
23557       (arg1)->Release();
23558     } catch (std::out_of_range& e) {
23559       {
23560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23561       };
23562     } catch (std::exception& e) {
23563       {
23564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23565       };
23566     } catch (Dali::DaliException e) {
23567       {
23568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23569       };
23570     } catch (...) {
23571       {
23572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23573       };
23574     }
23575   }
23576
23577 }
23578
23579
23580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23581   int jresult ;
23582   Dali::Pixel::Format result;
23583
23584   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23585   jresult = (int)result;
23586   return jresult;
23587 }
23588
23589
23590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23591   int jresult ;
23592   Dali::Pixel::Format result;
23593
23594   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23595   jresult = (int)result;
23596   return jresult;
23597 }
23598
23599
23600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23601   unsigned int jresult ;
23602   Dali::Pixel::Format arg1 ;
23603   bool result;
23604
23605   arg1 = (Dali::Pixel::Format)jarg1;
23606   {
23607     try {
23608       result = (bool)Dali::Pixel::HasAlpha(arg1);
23609     } catch (std::out_of_range& e) {
23610       {
23611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23612       };
23613     } catch (std::exception& e) {
23614       {
23615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23616       };
23617     } catch (Dali::DaliException e) {
23618       {
23619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23620       };
23621     } catch (...) {
23622       {
23623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23624       };
23625     }
23626   }
23627
23628   jresult = result;
23629   return jresult;
23630 }
23631
23632
23633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23634   unsigned int jresult ;
23635   Dali::Pixel::Format arg1 ;
23636   unsigned int result;
23637
23638   arg1 = (Dali::Pixel::Format)jarg1;
23639   {
23640     try {
23641       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(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 void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23667   Dali::Pixel::Format arg1 ;
23668   int *arg2 = 0 ;
23669   int *arg3 = 0 ;
23670
23671   arg1 = (Dali::Pixel::Format)jarg1;
23672   arg2 = (int *)jarg2;
23673   if (!arg2) {
23674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23675     return ;
23676   }
23677   arg3 = (int *)jarg3;
23678   if (!arg3) {
23679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23680     return ;
23681   }
23682   {
23683     try {
23684       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23685     } catch (std::out_of_range& e) {
23686       {
23687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23688       };
23689     } catch (std::exception& e) {
23690       {
23691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23692       };
23693     } catch (Dali::DaliException e) {
23694       {
23695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23696       };
23697     } catch (...) {
23698       {
23699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23700       };
23701     }
23702   }
23703
23704 }
23705
23706
23707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23708   void * jresult ;
23709   unsigned char *arg1 = (unsigned char *) 0 ;
23710   unsigned int arg2 ;
23711   unsigned int arg3 ;
23712   unsigned int arg4 ;
23713   Dali::Pixel::Format arg5 ;
23714   Dali::PixelData::ReleaseFunction arg6 ;
23715   Dali::PixelData result;
23716
23717   arg1 = jarg1;
23718   arg2 = (unsigned int)jarg2;
23719   arg3 = (unsigned int)jarg3;
23720   arg4 = (unsigned int)jarg4;
23721   arg5 = (Dali::Pixel::Format)jarg5;
23722   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23723   {
23724     try {
23725       auto pixelBuffer = new unsigned char[jarg2];
23726       memcpy( pixelBuffer, arg1, arg2);
23727       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23728     } catch (std::out_of_range& e) {
23729       {
23730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23731       };
23732     } catch (std::exception& e) {
23733       {
23734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23735       };
23736     } catch (Dali::DaliException e) {
23737       {
23738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23739       };
23740     } catch (...) {
23741       {
23742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23743       };
23744     }
23745   }
23746
23747   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23748
23749
23750   return jresult;
23751 }
23752
23753
23754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
23755   void * jresult ;
23756   Dali::PixelData *result = 0 ;
23757
23758   {
23759     try {
23760       result = (Dali::PixelData *)new Dali::PixelData();
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 = (void *)result;
23781   return jresult;
23782 }
23783
23784
23785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
23786   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23787
23788   arg1 = (Dali::PixelData *)jarg1;
23789   {
23790     try {
23791       delete arg1;
23792     } catch (std::out_of_range& e) {
23793       {
23794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23795       };
23796     } catch (std::exception& e) {
23797       {
23798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23799       };
23800     } catch (Dali::DaliException e) {
23801       {
23802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23803       };
23804     } catch (...) {
23805       {
23806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23807       };
23808     }
23809   }
23810
23811 }
23812
23813
23814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
23815   void * jresult ;
23816   Dali::PixelData *arg1 = 0 ;
23817   Dali::PixelData *result = 0 ;
23818
23819   arg1 = (Dali::PixelData *)jarg1;
23820   if (!arg1) {
23821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23822     return 0;
23823   }
23824   {
23825     try {
23826       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
23827     } catch (std::out_of_range& e) {
23828       {
23829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23830       };
23831     } catch (std::exception& e) {
23832       {
23833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23834       };
23835     } catch (Dali::DaliException e) {
23836       {
23837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23838       };
23839     } catch (...) {
23840       {
23841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23842       };
23843     }
23844   }
23845
23846   jresult = (void *)result;
23847   return jresult;
23848 }
23849
23850
23851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
23852   void * jresult ;
23853   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23854   Dali::PixelData *arg2 = 0 ;
23855   Dali::PixelData *result = 0 ;
23856
23857   arg1 = (Dali::PixelData *)jarg1;
23858   arg2 = (Dali::PixelData *)jarg2;
23859   if (!arg2) {
23860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23861     return 0;
23862   }
23863   {
23864     try {
23865       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
23866     } catch (std::out_of_range& e) {
23867       {
23868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23869       };
23870     } catch (std::exception& e) {
23871       {
23872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23873       };
23874     } catch (Dali::DaliException e) {
23875       {
23876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23877       };
23878     } catch (...) {
23879       {
23880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23881       };
23882     }
23883   }
23884
23885   jresult = (void *)result;
23886   return jresult;
23887 }
23888
23889
23890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
23891   unsigned int jresult ;
23892   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23893   unsigned int result;
23894
23895   arg1 = (Dali::PixelData *)jarg1;
23896   {
23897     try {
23898       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
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 = result;
23919   return jresult;
23920 }
23921
23922
23923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(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)->GetHeight();
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 int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
23957   int jresult ;
23958   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23959   Dali::Pixel::Format result;
23960
23961   arg1 = (Dali::PixelData *)jarg1;
23962   {
23963     try {
23964       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
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 = (int)result;
23985   return jresult;
23986 }
23987
23988
23989 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
23990   unsigned int jresult ;
23991   unsigned int result;
23992
23993   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
23994   jresult = result;
23995   return jresult;
23996 }
23997
23998
23999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24000   unsigned int jresult ;
24001   unsigned int result;
24002
24003   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24004   jresult = result;
24005   return jresult;
24006 }
24007
24008
24009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24010   unsigned int jresult ;
24011   unsigned int result;
24012
24013   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24014   jresult = result;
24015   return jresult;
24016 }
24017
24018
24019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24020   unsigned int jresult ;
24021   unsigned int result;
24022
24023   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24024   jresult = result;
24025   return jresult;
24026 }
24027
24028
24029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24030   unsigned int jresult ;
24031   unsigned int result;
24032
24033   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24034   jresult = result;
24035   return jresult;
24036 }
24037
24038
24039 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24040   unsigned int jresult ;
24041   unsigned int result;
24042
24043   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24044   jresult = result;
24045   return jresult;
24046 }
24047
24048
24049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24050   void * jresult ;
24051   Dali::TextureType::Type arg1 ;
24052   Dali::Pixel::Format arg2 ;
24053   unsigned int arg3 ;
24054   unsigned int arg4 ;
24055   Dali::Texture result;
24056
24057   arg1 = (Dali::TextureType::Type)jarg1;
24058   arg2 = (Dali::Pixel::Format)jarg2;
24059   arg3 = (unsigned int)jarg3;
24060   arg4 = (unsigned int)jarg4;
24061   {
24062     try {
24063       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24064     } catch (std::out_of_range& e) {
24065       {
24066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24067       };
24068     } catch (std::exception& e) {
24069       {
24070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24071       };
24072     } catch (Dali::DaliException e) {
24073       {
24074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24075       };
24076     } catch (...) {
24077       {
24078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24079       };
24080     }
24081   }
24082
24083   jresult = new Dali::Texture((const Dali::Texture &)result);
24084   return jresult;
24085 }
24086
24087
24088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24089   void * jresult ;
24090   NativeImageInterface *arg1 = 0 ;
24091   Dali::Texture result;
24092
24093   arg1 = (NativeImageInterface *)jarg1;
24094   if (!arg1) {
24095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24096     return 0;
24097   }
24098   {
24099     try {
24100       result = Dali::Texture::New(*arg1);
24101     } catch (std::out_of_range& e) {
24102       {
24103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24104       };
24105     } catch (std::exception& e) {
24106       {
24107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24108       };
24109     } catch (Dali::DaliException e) {
24110       {
24111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24112       };
24113     } catch (...) {
24114       {
24115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24116       };
24117     }
24118   }
24119
24120   jresult = new Dali::Texture((const Dali::Texture &)result);
24121   return jresult;
24122 }
24123
24124
24125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24126   void * jresult ;
24127   Dali::Texture *result = 0 ;
24128
24129   {
24130     try {
24131       result = (Dali::Texture *)new Dali::Texture();
24132     } catch (std::out_of_range& e) {
24133       {
24134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24135       };
24136     } catch (std::exception& e) {
24137       {
24138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24139       };
24140     } catch (Dali::DaliException e) {
24141       {
24142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24143       };
24144     } catch (...) {
24145       {
24146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24147       };
24148     }
24149   }
24150
24151   jresult = (void *)result;
24152   return jresult;
24153 }
24154
24155
24156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24157   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24158
24159   arg1 = (Dali::Texture *)jarg1;
24160   {
24161     try {
24162       delete arg1;
24163     } catch (std::out_of_range& e) {
24164       {
24165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24166       };
24167     } catch (std::exception& e) {
24168       {
24169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24170       };
24171     } catch (Dali::DaliException e) {
24172       {
24173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24174       };
24175     } catch (...) {
24176       {
24177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24178       };
24179     }
24180   }
24181
24182 }
24183
24184
24185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24186   void * jresult ;
24187   Dali::Texture *arg1 = 0 ;
24188   Dali::Texture *result = 0 ;
24189
24190   arg1 = (Dali::Texture *)jarg1;
24191   if (!arg1) {
24192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24193     return 0;
24194   }
24195   {
24196     try {
24197       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24198     } catch (std::out_of_range& e) {
24199       {
24200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24201       };
24202     } catch (std::exception& e) {
24203       {
24204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24205       };
24206     } catch (Dali::DaliException e) {
24207       {
24208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24209       };
24210     } catch (...) {
24211       {
24212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24213       };
24214     }
24215   }
24216
24217   jresult = (void *)result;
24218   return jresult;
24219 }
24220
24221
24222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24223   void * jresult ;
24224   Dali::BaseHandle arg1 ;
24225   Dali::BaseHandle *argp1 ;
24226   Dali::Texture result;
24227
24228   argp1 = (Dali::BaseHandle *)jarg1;
24229   if (!argp1) {
24230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24231     return 0;
24232   }
24233   arg1 = *argp1;
24234   {
24235     try {
24236       result = Dali::Texture::DownCast(arg1);
24237     } catch (std::out_of_range& e) {
24238       {
24239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24240       };
24241     } catch (std::exception& e) {
24242       {
24243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24244       };
24245     } catch (Dali::DaliException e) {
24246       {
24247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24248       };
24249     } catch (...) {
24250       {
24251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24252       };
24253     }
24254   }
24255
24256   jresult = new Dali::Texture((const Dali::Texture &)result);
24257   return jresult;
24258 }
24259
24260
24261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24262   void * jresult ;
24263   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24264   Dali::Texture *arg2 = 0 ;
24265   Dali::Texture *result = 0 ;
24266
24267   arg1 = (Dali::Texture *)jarg1;
24268   arg2 = (Dali::Texture *)jarg2;
24269   if (!arg2) {
24270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24271     return 0;
24272   }
24273   {
24274     try {
24275       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24276     } catch (std::out_of_range& e) {
24277       {
24278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24279       };
24280     } catch (std::exception& e) {
24281       {
24282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24283       };
24284     } catch (Dali::DaliException e) {
24285       {
24286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24287       };
24288     } catch (...) {
24289       {
24290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24291       };
24292     }
24293   }
24294
24295   jresult = (void *)result;
24296   return jresult;
24297 }
24298
24299
24300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24301   unsigned int jresult ;
24302   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24303   Dali::PixelData arg2 ;
24304   Dali::PixelData *argp2 ;
24305   bool result;
24306
24307   arg1 = (Dali::Texture *)jarg1;
24308   argp2 = (Dali::PixelData *)jarg2;
24309   if (!argp2) {
24310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24311     return 0;
24312   }
24313   arg2 = *argp2;
24314   {
24315     try {
24316       result = (bool)(arg1)->Upload(arg2);
24317     } catch (std::out_of_range& e) {
24318       {
24319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24320       };
24321     } catch (std::exception& e) {
24322       {
24323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24324       };
24325     } catch (Dali::DaliException e) {
24326       {
24327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24328       };
24329     } catch (...) {
24330       {
24331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24332       };
24333     }
24334   }
24335
24336   jresult = result;
24337   return jresult;
24338 }
24339
24340
24341 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) {
24342   unsigned int jresult ;
24343   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24344   Dali::PixelData arg2 ;
24345   unsigned int arg3 ;
24346   unsigned int arg4 ;
24347   unsigned int arg5 ;
24348   unsigned int arg6 ;
24349   unsigned int arg7 ;
24350   unsigned int arg8 ;
24351   Dali::PixelData *argp2 ;
24352   bool result;
24353
24354   arg1 = (Dali::Texture *)jarg1;
24355   argp2 = (Dali::PixelData *)jarg2;
24356   if (!argp2) {
24357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24358     return 0;
24359   }
24360   arg2 = *argp2;
24361   arg3 = (unsigned int)jarg3;
24362   arg4 = (unsigned int)jarg4;
24363   arg5 = (unsigned int)jarg5;
24364   arg6 = (unsigned int)jarg6;
24365   arg7 = (unsigned int)jarg7;
24366   arg8 = (unsigned int)jarg8;
24367   {
24368     try {
24369       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24370     } catch (std::out_of_range& e) {
24371       {
24372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24373       };
24374     } catch (std::exception& e) {
24375       {
24376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24377       };
24378     } catch (Dali::DaliException e) {
24379       {
24380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24381       };
24382     } catch (...) {
24383       {
24384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24385       };
24386     }
24387   }
24388
24389   jresult = result;
24390   return jresult;
24391 }
24392
24393
24394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24395   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24396
24397   arg1 = (Dali::Texture *)jarg1;
24398   {
24399     try {
24400       (arg1)->GenerateMipmaps();
24401     } catch (std::out_of_range& e) {
24402       {
24403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24404       };
24405     } catch (std::exception& e) {
24406       {
24407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24408       };
24409     } catch (Dali::DaliException e) {
24410       {
24411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24412       };
24413     } catch (...) {
24414       {
24415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24416       };
24417     }
24418   }
24419
24420 }
24421
24422
24423 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24424   unsigned int jresult ;
24425   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24426   unsigned int result;
24427
24428   arg1 = (Dali::Texture *)jarg1;
24429   {
24430     try {
24431       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24432     } catch (std::out_of_range& e) {
24433       {
24434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24435       };
24436     } catch (std::exception& e) {
24437       {
24438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24439       };
24440     } catch (Dali::DaliException e) {
24441       {
24442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24443       };
24444     } catch (...) {
24445       {
24446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24447       };
24448     }
24449   }
24450
24451   jresult = result;
24452   return jresult;
24453 }
24454
24455
24456 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(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)->GetHeight();
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 void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24490   void * jresult ;
24491   Dali::Sampler result;
24492
24493   {
24494     try {
24495       result = Dali::Sampler::New();
24496     } catch (std::out_of_range& e) {
24497       {
24498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24499       };
24500     } catch (std::exception& e) {
24501       {
24502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24503       };
24504     } catch (Dali::DaliException e) {
24505       {
24506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24507       };
24508     } catch (...) {
24509       {
24510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24511       };
24512     }
24513   }
24514
24515   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24516   return jresult;
24517 }
24518
24519
24520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24521   void * jresult ;
24522   Dali::Sampler *result = 0 ;
24523
24524   {
24525     try {
24526       result = (Dali::Sampler *)new Dali::Sampler();
24527     } catch (std::out_of_range& e) {
24528       {
24529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24530       };
24531     } catch (std::exception& e) {
24532       {
24533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24534       };
24535     } catch (Dali::DaliException e) {
24536       {
24537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24538       };
24539     } catch (...) {
24540       {
24541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24542       };
24543     }
24544   }
24545
24546   jresult = (void *)result;
24547   return jresult;
24548 }
24549
24550
24551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24552   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24553
24554   arg1 = (Dali::Sampler *)jarg1;
24555   {
24556     try {
24557       delete arg1;
24558     } catch (std::out_of_range& e) {
24559       {
24560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24561       };
24562     } catch (std::exception& e) {
24563       {
24564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24565       };
24566     } catch (Dali::DaliException e) {
24567       {
24568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24569       };
24570     } catch (...) {
24571       {
24572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24573       };
24574     }
24575   }
24576
24577 }
24578
24579
24580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24581   void * jresult ;
24582   Dali::Sampler *arg1 = 0 ;
24583   Dali::Sampler *result = 0 ;
24584
24585   arg1 = (Dali::Sampler *)jarg1;
24586   if (!arg1) {
24587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24588     return 0;
24589   }
24590   {
24591     try {
24592       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24593     } catch (std::out_of_range& e) {
24594       {
24595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24596       };
24597     } catch (std::exception& e) {
24598       {
24599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24600       };
24601     } catch (Dali::DaliException e) {
24602       {
24603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24604       };
24605     } catch (...) {
24606       {
24607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24608       };
24609     }
24610   }
24611
24612   jresult = (void *)result;
24613   return jresult;
24614 }
24615
24616
24617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24618   void * jresult ;
24619   Dali::BaseHandle arg1 ;
24620   Dali::BaseHandle *argp1 ;
24621   Dali::Sampler result;
24622
24623   argp1 = (Dali::BaseHandle *)jarg1;
24624   if (!argp1) {
24625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24626     return 0;
24627   }
24628   arg1 = *argp1;
24629   {
24630     try {
24631       result = Dali::Sampler::DownCast(arg1);
24632     } catch (std::out_of_range& e) {
24633       {
24634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24635       };
24636     } catch (std::exception& e) {
24637       {
24638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24639       };
24640     } catch (Dali::DaliException e) {
24641       {
24642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24643       };
24644     } catch (...) {
24645       {
24646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24647       };
24648     }
24649   }
24650
24651   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24652   return jresult;
24653 }
24654
24655
24656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24657   void * jresult ;
24658   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24659   Dali::Sampler *arg2 = 0 ;
24660   Dali::Sampler *result = 0 ;
24661
24662   arg1 = (Dali::Sampler *)jarg1;
24663   arg2 = (Dali::Sampler *)jarg2;
24664   if (!arg2) {
24665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24666     return 0;
24667   }
24668   {
24669     try {
24670       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24671     } catch (std::out_of_range& e) {
24672       {
24673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24674       };
24675     } catch (std::exception& e) {
24676       {
24677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24678       };
24679     } catch (Dali::DaliException e) {
24680       {
24681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24682       };
24683     } catch (...) {
24684       {
24685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24686       };
24687     }
24688   }
24689
24690   jresult = (void *)result;
24691   return jresult;
24692 }
24693
24694
24695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24696   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24697   Dali::FilterMode::Type arg2 ;
24698   Dali::FilterMode::Type arg3 ;
24699
24700   arg1 = (Dali::Sampler *)jarg1;
24701   arg2 = (Dali::FilterMode::Type)jarg2;
24702   arg3 = (Dali::FilterMode::Type)jarg3;
24703   {
24704     try {
24705       (arg1)->SetFilterMode(arg2,arg3);
24706     } catch (std::out_of_range& e) {
24707       {
24708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24709       };
24710     } catch (std::exception& e) {
24711       {
24712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24713       };
24714     } catch (Dali::DaliException e) {
24715       {
24716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24717       };
24718     } catch (...) {
24719       {
24720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24721       };
24722     }
24723   }
24724
24725 }
24726
24727
24728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24729   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24730   Dali::WrapMode::Type arg2 ;
24731   Dali::WrapMode::Type arg3 ;
24732
24733   arg1 = (Dali::Sampler *)jarg1;
24734   arg2 = (Dali::WrapMode::Type)jarg2;
24735   arg3 = (Dali::WrapMode::Type)jarg3;
24736   {
24737     try {
24738       (arg1)->SetWrapMode(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_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
24762   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24763   Dali::WrapMode::Type arg2 ;
24764   Dali::WrapMode::Type arg3 ;
24765   Dali::WrapMode::Type arg4 ;
24766
24767   arg1 = (Dali::Sampler *)jarg1;
24768   arg2 = (Dali::WrapMode::Type)jarg2;
24769   arg3 = (Dali::WrapMode::Type)jarg3;
24770   arg4 = (Dali::WrapMode::Type)jarg4;
24771   {
24772     try {
24773       (arg1)->SetWrapMode(arg2,arg3,arg4);
24774     } catch (std::out_of_range& e) {
24775       {
24776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24777       };
24778     } catch (std::exception& e) {
24779       {
24780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24781       };
24782     } catch (Dali::DaliException e) {
24783       {
24784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24785       };
24786     } catch (...) {
24787       {
24788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24789       };
24790     }
24791   }
24792
24793 }
24794
24795
24796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
24797   void * jresult ;
24798   Dali::TextureSet result;
24799
24800   {
24801     try {
24802       result = Dali::TextureSet::New();
24803     } catch (std::out_of_range& e) {
24804       {
24805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24806       };
24807     } catch (std::exception& e) {
24808       {
24809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24810       };
24811     } catch (Dali::DaliException e) {
24812       {
24813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24814       };
24815     } catch (...) {
24816       {
24817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24818       };
24819     }
24820   }
24821
24822   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24823   return jresult;
24824 }
24825
24826
24827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
24828   void * jresult ;
24829   Dali::TextureSet *result = 0 ;
24830
24831   {
24832     try {
24833       result = (Dali::TextureSet *)new Dali::TextureSet();
24834     } catch (std::out_of_range& e) {
24835       {
24836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24837       };
24838     } catch (std::exception& e) {
24839       {
24840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24841       };
24842     } catch (Dali::DaliException e) {
24843       {
24844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24845       };
24846     } catch (...) {
24847       {
24848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24849       };
24850     }
24851   }
24852
24853   jresult = (void *)result;
24854   return jresult;
24855 }
24856
24857
24858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
24859   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24860
24861   arg1 = (Dali::TextureSet *)jarg1;
24862   {
24863     try {
24864       delete arg1;
24865     } catch (std::out_of_range& e) {
24866       {
24867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24868       };
24869     } catch (std::exception& e) {
24870       {
24871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24872       };
24873     } catch (Dali::DaliException e) {
24874       {
24875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24876       };
24877     } catch (...) {
24878       {
24879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24880       };
24881     }
24882   }
24883
24884 }
24885
24886
24887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
24888   void * jresult ;
24889   Dali::TextureSet *arg1 = 0 ;
24890   Dali::TextureSet *result = 0 ;
24891
24892   arg1 = (Dali::TextureSet *)jarg1;
24893   if (!arg1) {
24894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24895     return 0;
24896   }
24897   {
24898     try {
24899       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
24900     } catch (std::out_of_range& e) {
24901       {
24902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24903       };
24904     } catch (std::exception& e) {
24905       {
24906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24907       };
24908     } catch (Dali::DaliException e) {
24909       {
24910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24911       };
24912     } catch (...) {
24913       {
24914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24915       };
24916     }
24917   }
24918
24919   jresult = (void *)result;
24920   return jresult;
24921 }
24922
24923
24924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
24925   void * jresult ;
24926   Dali::BaseHandle arg1 ;
24927   Dali::BaseHandle *argp1 ;
24928   Dali::TextureSet result;
24929
24930   argp1 = (Dali::BaseHandle *)jarg1;
24931   if (!argp1) {
24932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24933     return 0;
24934   }
24935   arg1 = *argp1;
24936   {
24937     try {
24938       result = Dali::TextureSet::DownCast(arg1);
24939     } catch (std::out_of_range& e) {
24940       {
24941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24942       };
24943     } catch (std::exception& e) {
24944       {
24945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24946       };
24947     } catch (Dali::DaliException e) {
24948       {
24949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24950       };
24951     } catch (...) {
24952       {
24953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24954       };
24955     }
24956   }
24957
24958   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24959   return jresult;
24960 }
24961
24962
24963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
24964   void * jresult ;
24965   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24966   Dali::TextureSet *arg2 = 0 ;
24967   Dali::TextureSet *result = 0 ;
24968
24969   arg1 = (Dali::TextureSet *)jarg1;
24970   arg2 = (Dali::TextureSet *)jarg2;
24971   if (!arg2) {
24972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24973     return 0;
24974   }
24975   {
24976     try {
24977       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
24978     } catch (std::out_of_range& e) {
24979       {
24980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24981       };
24982     } catch (std::exception& e) {
24983       {
24984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24985       };
24986     } catch (Dali::DaliException e) {
24987       {
24988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24989       };
24990     } catch (...) {
24991       {
24992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24993       };
24994     }
24995   }
24996
24997   jresult = (void *)result;
24998   return jresult;
24999 }
25000
25001
25002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25003   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25004   size_t arg2 ;
25005   Dali::Texture arg3 ;
25006   Dali::Texture *argp3 ;
25007
25008   arg1 = (Dali::TextureSet *)jarg1;
25009   arg2 = (size_t)jarg2;
25010   argp3 = (Dali::Texture *)jarg3;
25011   if (!argp3) {
25012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25013     return ;
25014   }
25015   arg3 = *argp3;
25016   {
25017     try {
25018       (arg1)->SetTexture(arg2,arg3);
25019     } catch (std::out_of_range& e) {
25020       {
25021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25022       };
25023     } catch (std::exception& e) {
25024       {
25025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25026       };
25027     } catch (Dali::DaliException e) {
25028       {
25029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25030       };
25031     } catch (...) {
25032       {
25033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25034       };
25035     }
25036   }
25037
25038 }
25039
25040
25041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25042   void * jresult ;
25043   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25044   size_t arg2 ;
25045   Dali::Texture result;
25046
25047   arg1 = (Dali::TextureSet *)jarg1;
25048   arg2 = (size_t)jarg2;
25049   {
25050     try {
25051       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25052     } catch (std::out_of_range& e) {
25053       {
25054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25055       };
25056     } catch (std::exception& e) {
25057       {
25058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25059       };
25060     } catch (Dali::DaliException e) {
25061       {
25062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25063       };
25064     } catch (...) {
25065       {
25066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25067       };
25068     }
25069   }
25070
25071   jresult = new Dali::Texture((const Dali::Texture &)result);
25072   return jresult;
25073 }
25074
25075
25076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25077   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25078   size_t arg2 ;
25079   Dali::Sampler arg3 ;
25080   Dali::Sampler *argp3 ;
25081
25082   arg1 = (Dali::TextureSet *)jarg1;
25083   arg2 = (size_t)jarg2;
25084   argp3 = (Dali::Sampler *)jarg3;
25085   if (!argp3) {
25086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25087     return ;
25088   }
25089   arg3 = *argp3;
25090   {
25091     try {
25092       (arg1)->SetSampler(arg2,arg3);
25093     } catch (std::out_of_range& e) {
25094       {
25095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25096       };
25097     } catch (std::exception& e) {
25098       {
25099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25100       };
25101     } catch (Dali::DaliException e) {
25102       {
25103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25104       };
25105     } catch (...) {
25106       {
25107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25108       };
25109     }
25110   }
25111
25112 }
25113
25114
25115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25116   void * jresult ;
25117   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25118   size_t arg2 ;
25119   Dali::Sampler result;
25120
25121   arg1 = (Dali::TextureSet *)jarg1;
25122   arg2 = (size_t)jarg2;
25123   {
25124     try {
25125       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25126     } catch (std::out_of_range& e) {
25127       {
25128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25129       };
25130     } catch (std::exception& e) {
25131       {
25132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25133       };
25134     } catch (Dali::DaliException e) {
25135       {
25136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25137       };
25138     } catch (...) {
25139       {
25140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25141       };
25142     }
25143   }
25144
25145   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25146   return jresult;
25147 }
25148
25149
25150 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25151   unsigned long jresult ;
25152   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25153   size_t result;
25154
25155   arg1 = (Dali::TextureSet *)jarg1;
25156   {
25157     try {
25158       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
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 = (unsigned long)result;
25179   return jresult;
25180 }
25181
25182
25183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25184   void * jresult ;
25185   Dali::Property::Map *arg1 = 0 ;
25186   Dali::PropertyBuffer result;
25187
25188   arg1 = (Dali::Property::Map *)jarg1;
25189   if (!arg1) {
25190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25191     return 0;
25192   }
25193   {
25194     try {
25195       result = Dali::PropertyBuffer::New(*arg1);
25196     } catch (std::out_of_range& e) {
25197       {
25198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25199       };
25200     } catch (std::exception& e) {
25201       {
25202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25203       };
25204     } catch (Dali::DaliException e) {
25205       {
25206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25207       };
25208     } catch (...) {
25209       {
25210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25211       };
25212     }
25213   }
25214
25215   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25216   return jresult;
25217 }
25218
25219
25220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25221   void * jresult ;
25222   Dali::PropertyBuffer *result = 0 ;
25223
25224   {
25225     try {
25226       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25227     } catch (std::out_of_range& e) {
25228       {
25229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25230       };
25231     } catch (std::exception& e) {
25232       {
25233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25234       };
25235     } catch (Dali::DaliException e) {
25236       {
25237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25238       };
25239     } catch (...) {
25240       {
25241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25242       };
25243     }
25244   }
25245
25246   jresult = (void *)result;
25247   return jresult;
25248 }
25249
25250
25251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25252   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25253
25254   arg1 = (Dali::PropertyBuffer *)jarg1;
25255   {
25256     try {
25257       delete arg1;
25258     } catch (std::out_of_range& e) {
25259       {
25260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25261       };
25262     } catch (std::exception& e) {
25263       {
25264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25265       };
25266     } catch (Dali::DaliException e) {
25267       {
25268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25269       };
25270     } catch (...) {
25271       {
25272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25273       };
25274     }
25275   }
25276
25277 }
25278
25279
25280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25281   void * jresult ;
25282   Dali::PropertyBuffer *arg1 = 0 ;
25283   Dali::PropertyBuffer *result = 0 ;
25284
25285   arg1 = (Dali::PropertyBuffer *)jarg1;
25286   if (!arg1) {
25287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25288     return 0;
25289   }
25290   {
25291     try {
25292       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25293     } catch (std::out_of_range& e) {
25294       {
25295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25296       };
25297     } catch (std::exception& e) {
25298       {
25299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25300       };
25301     } catch (Dali::DaliException e) {
25302       {
25303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25304       };
25305     } catch (...) {
25306       {
25307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25308       };
25309     }
25310   }
25311
25312   jresult = (void *)result;
25313   return jresult;
25314 }
25315
25316
25317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25318   void * jresult ;
25319   Dali::BaseHandle arg1 ;
25320   Dali::BaseHandle *argp1 ;
25321   Dali::PropertyBuffer result;
25322
25323   argp1 = (Dali::BaseHandle *)jarg1;
25324   if (!argp1) {
25325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25326     return 0;
25327   }
25328   arg1 = *argp1;
25329   {
25330     try {
25331       result = Dali::PropertyBuffer::DownCast(arg1);
25332     } catch (std::out_of_range& e) {
25333       {
25334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25335       };
25336     } catch (std::exception& e) {
25337       {
25338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25339       };
25340     } catch (Dali::DaliException e) {
25341       {
25342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25343       };
25344     } catch (...) {
25345       {
25346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25347       };
25348     }
25349   }
25350
25351   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25352   return jresult;
25353 }
25354
25355
25356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25357   void * jresult ;
25358   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25359   Dali::PropertyBuffer *arg2 = 0 ;
25360   Dali::PropertyBuffer *result = 0 ;
25361
25362   arg1 = (Dali::PropertyBuffer *)jarg1;
25363   arg2 = (Dali::PropertyBuffer *)jarg2;
25364   if (!arg2) {
25365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25366     return 0;
25367   }
25368   {
25369     try {
25370       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25371     } catch (std::out_of_range& e) {
25372       {
25373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25374       };
25375     } catch (std::exception& e) {
25376       {
25377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25378       };
25379     } catch (Dali::DaliException e) {
25380       {
25381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25382       };
25383     } catch (...) {
25384       {
25385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25386       };
25387     }
25388   }
25389
25390   jresult = (void *)result;
25391   return jresult;
25392 }
25393
25394
25395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25396   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25397   void *arg2 = (void *) 0 ;
25398   std::size_t arg3 ;
25399
25400   arg1 = (Dali::PropertyBuffer *)jarg1;
25401   arg2 = jarg2;
25402   arg3 = (std::size_t)jarg3;
25403   {
25404     try {
25405       (arg1)->SetData((void const *)arg2,arg3);
25406     } catch (std::out_of_range& e) {
25407       {
25408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25409       };
25410     } catch (std::exception& e) {
25411       {
25412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25413       };
25414     } catch (Dali::DaliException e) {
25415       {
25416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25417       };
25418     } catch (...) {
25419       {
25420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25421       };
25422     }
25423   }
25424
25425 }
25426
25427
25428 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25429   unsigned long jresult ;
25430   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25431   std::size_t result;
25432
25433   arg1 = (Dali::PropertyBuffer *)jarg1;
25434   {
25435     try {
25436       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25437     } catch (std::out_of_range& e) {
25438       {
25439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25440       };
25441     } catch (std::exception& e) {
25442       {
25443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25444       };
25445     } catch (Dali::DaliException e) {
25446       {
25447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25448       };
25449     } catch (...) {
25450       {
25451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25452       };
25453     }
25454   }
25455
25456   jresult = (unsigned long)result;
25457   return jresult;
25458 }
25459
25460
25461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25462   void * jresult ;
25463   Dali::Geometry result;
25464
25465   {
25466     try {
25467       result = Dali::Geometry::New();
25468     } catch (std::out_of_range& e) {
25469       {
25470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25471       };
25472     } catch (std::exception& e) {
25473       {
25474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25475       };
25476     } catch (Dali::DaliException e) {
25477       {
25478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25479       };
25480     } catch (...) {
25481       {
25482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25483       };
25484     }
25485   }
25486
25487   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25488   return jresult;
25489 }
25490
25491
25492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25493   void * jresult ;
25494   Dali::Geometry *result = 0 ;
25495
25496   {
25497     try {
25498       result = (Dali::Geometry *)new Dali::Geometry();
25499     } catch (std::out_of_range& e) {
25500       {
25501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25502       };
25503     } catch (std::exception& e) {
25504       {
25505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25506       };
25507     } catch (Dali::DaliException e) {
25508       {
25509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25510       };
25511     } catch (...) {
25512       {
25513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25514       };
25515     }
25516   }
25517
25518   jresult = (void *)result;
25519   return jresult;
25520 }
25521
25522
25523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25524   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25525
25526   arg1 = (Dali::Geometry *)jarg1;
25527   {
25528     try {
25529       delete arg1;
25530     } catch (std::out_of_range& e) {
25531       {
25532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25533       };
25534     } catch (std::exception& e) {
25535       {
25536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25537       };
25538     } catch (Dali::DaliException e) {
25539       {
25540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25541       };
25542     } catch (...) {
25543       {
25544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25545       };
25546     }
25547   }
25548
25549 }
25550
25551
25552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25553   void * jresult ;
25554   Dali::Geometry *arg1 = 0 ;
25555   Dali::Geometry *result = 0 ;
25556
25557   arg1 = (Dali::Geometry *)jarg1;
25558   if (!arg1) {
25559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25560     return 0;
25561   }
25562   {
25563     try {
25564       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25565     } catch (std::out_of_range& e) {
25566       {
25567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25568       };
25569     } catch (std::exception& e) {
25570       {
25571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25572       };
25573     } catch (Dali::DaliException e) {
25574       {
25575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25576       };
25577     } catch (...) {
25578       {
25579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25580       };
25581     }
25582   }
25583
25584   jresult = (void *)result;
25585   return jresult;
25586 }
25587
25588
25589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25590   void * jresult ;
25591   Dali::BaseHandle arg1 ;
25592   Dali::BaseHandle *argp1 ;
25593   Dali::Geometry result;
25594
25595   argp1 = (Dali::BaseHandle *)jarg1;
25596   if (!argp1) {
25597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25598     return 0;
25599   }
25600   arg1 = *argp1;
25601   {
25602     try {
25603       result = Dali::Geometry::DownCast(arg1);
25604     } catch (std::out_of_range& e) {
25605       {
25606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25607       };
25608     } catch (std::exception& e) {
25609       {
25610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25611       };
25612     } catch (Dali::DaliException e) {
25613       {
25614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25615       };
25616     } catch (...) {
25617       {
25618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25619       };
25620     }
25621   }
25622
25623   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25624   return jresult;
25625 }
25626
25627
25628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25629   void * jresult ;
25630   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25631   Dali::Geometry *arg2 = 0 ;
25632   Dali::Geometry *result = 0 ;
25633
25634   arg1 = (Dali::Geometry *)jarg1;
25635   arg2 = (Dali::Geometry *)jarg2;
25636   if (!arg2) {
25637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25638     return 0;
25639   }
25640   {
25641     try {
25642       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25643     } catch (std::out_of_range& e) {
25644       {
25645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25646       };
25647     } catch (std::exception& e) {
25648       {
25649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25650       };
25651     } catch (Dali::DaliException e) {
25652       {
25653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25654       };
25655     } catch (...) {
25656       {
25657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25658       };
25659     }
25660   }
25661
25662   jresult = (void *)result;
25663   return jresult;
25664 }
25665
25666
25667 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25668   unsigned long jresult ;
25669   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25670   Dali::PropertyBuffer *arg2 = 0 ;
25671   std::size_t result;
25672
25673   arg1 = (Dali::Geometry *)jarg1;
25674   arg2 = (Dali::PropertyBuffer *)jarg2;
25675   if (!arg2) {
25676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25677     return 0;
25678   }
25679   {
25680     try {
25681       result = (arg1)->AddVertexBuffer(*arg2);
25682     } catch (std::out_of_range& e) {
25683       {
25684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25685       };
25686     } catch (std::exception& e) {
25687       {
25688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25689       };
25690     } catch (Dali::DaliException e) {
25691       {
25692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25693       };
25694     } catch (...) {
25695       {
25696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25697       };
25698     }
25699   }
25700
25701   jresult = (unsigned long)result;
25702   return jresult;
25703 }
25704
25705
25706 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25707   unsigned long jresult ;
25708   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25709   std::size_t result;
25710
25711   arg1 = (Dali::Geometry *)jarg1;
25712   {
25713     try {
25714       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
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 void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25740   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25741   std::size_t arg2 ;
25742
25743   arg1 = (Dali::Geometry *)jarg1;
25744   arg2 = (std::size_t)jarg2;
25745   {
25746     try {
25747       (arg1)->RemoveVertexBuffer(arg2);
25748     } catch (std::out_of_range& e) {
25749       {
25750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25751       };
25752     } catch (std::exception& e) {
25753       {
25754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25755       };
25756     } catch (Dali::DaliException e) {
25757       {
25758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25759       };
25760     } catch (...) {
25761       {
25762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25763       };
25764     }
25765   }
25766
25767 }
25768
25769
25770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
25771   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25772   unsigned short *arg2 = (unsigned short *) 0 ;
25773   size_t arg3 ;
25774
25775   arg1 = (Dali::Geometry *)jarg1;
25776   arg2 = jarg2;
25777   arg3 = (size_t)jarg3;
25778   {
25779     try {
25780       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
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
25804
25805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
25806   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25807   Dali::Geometry::Type arg2 ;
25808
25809   arg1 = (Dali::Geometry *)jarg1;
25810   arg2 = (Dali::Geometry::Type)jarg2;
25811   {
25812     try {
25813       (arg1)->SetType(arg2);
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 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
25837   int jresult ;
25838   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25839   Dali::Geometry::Type result;
25840
25841   arg1 = (Dali::Geometry *)jarg1;
25842   {
25843     try {
25844       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
25845     } catch (std::out_of_range& e) {
25846       {
25847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25848       };
25849     } catch (std::exception& e) {
25850       {
25851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25852       };
25853     } catch (Dali::DaliException e) {
25854       {
25855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25856       };
25857     } catch (...) {
25858       {
25859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25860       };
25861     }
25862   }
25863
25864   jresult = (int)result;
25865   return jresult;
25866 }
25867
25868
25869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
25870   void * jresult ;
25871   Dali::Shader::Hint *result = 0 ;
25872
25873   {
25874     try {
25875       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
25876     } catch (std::out_of_range& e) {
25877       {
25878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25879       };
25880     } catch (std::exception& e) {
25881       {
25882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25883       };
25884     } catch (Dali::DaliException e) {
25885       {
25886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25887       };
25888     } catch (...) {
25889       {
25890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25891       };
25892     }
25893   }
25894
25895   jresult = (void *)result;
25896   return jresult;
25897 }
25898
25899
25900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
25901   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
25902
25903   arg1 = (Dali::Shader::Hint *)jarg1;
25904   {
25905     try {
25906       delete arg1;
25907     } catch (std::out_of_range& e) {
25908       {
25909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25910       };
25911     } catch (std::exception& e) {
25912       {
25913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25914       };
25915     } catch (Dali::DaliException e) {
25916       {
25917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25918       };
25919     } catch (...) {
25920       {
25921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25922       };
25923     }
25924   }
25925
25926 }
25927
25928
25929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
25930   int jresult ;
25931   int result;
25932
25933   result = (int)Dali::Shader::Property::PROGRAM;
25934   jresult = (int)result;
25935   return jresult;
25936 }
25937
25938
25939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
25940   void * jresult ;
25941   Dali::Shader::Property *result = 0 ;
25942
25943   {
25944     try {
25945       result = (Dali::Shader::Property *)new Dali::Shader::Property();
25946     } catch (std::out_of_range& e) {
25947       {
25948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25949       };
25950     } catch (std::exception& e) {
25951       {
25952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25953       };
25954     } catch (Dali::DaliException e) {
25955       {
25956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25957       };
25958     } catch (...) {
25959       {
25960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25961       };
25962     }
25963   }
25964
25965   jresult = (void *)result;
25966   return jresult;
25967 }
25968
25969
25970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
25971   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
25972
25973   arg1 = (Dali::Shader::Property *)jarg1;
25974   {
25975     try {
25976       delete arg1;
25977     } catch (std::out_of_range& e) {
25978       {
25979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25980       };
25981     } catch (std::exception& e) {
25982       {
25983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25984       };
25985     } catch (Dali::DaliException e) {
25986       {
25987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25988       };
25989     } catch (...) {
25990       {
25991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25992       };
25993     }
25994   }
25995
25996 }
25997
25998
25999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26000   void * jresult ;
26001   std::string *arg1 = 0 ;
26002   std::string *arg2 = 0 ;
26003   Dali::Shader::Hint::Value arg3 ;
26004   Dali::Shader result;
26005
26006   if (!jarg1) {
26007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26008     return 0;
26009   }
26010   std::string arg1_str(jarg1);
26011   arg1 = &arg1_str;
26012   if (!jarg2) {
26013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26014     return 0;
26015   }
26016   std::string arg2_str(jarg2);
26017   arg2 = &arg2_str;
26018   arg3 = (Dali::Shader::Hint::Value)jarg3;
26019   {
26020     try {
26021       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26022     } catch (std::out_of_range& e) {
26023       {
26024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26025       };
26026     } catch (std::exception& e) {
26027       {
26028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26029       };
26030     } catch (Dali::DaliException e) {
26031       {
26032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26033       };
26034     } catch (...) {
26035       {
26036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26037       };
26038     }
26039   }
26040
26041   jresult = new Dali::Shader((const Dali::Shader &)result);
26042
26043   //argout typemap for const std::string&
26044
26045
26046   //argout typemap for const std::string&
26047
26048   return jresult;
26049 }
26050
26051
26052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26053   void * jresult ;
26054   std::string *arg1 = 0 ;
26055   std::string *arg2 = 0 ;
26056   Dali::Shader result;
26057
26058   if (!jarg1) {
26059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26060     return 0;
26061   }
26062   std::string arg1_str(jarg1);
26063   arg1 = &arg1_str;
26064   if (!jarg2) {
26065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26066     return 0;
26067   }
26068   std::string arg2_str(jarg2);
26069   arg2 = &arg2_str;
26070   {
26071     try {
26072       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26073     } catch (std::out_of_range& e) {
26074       {
26075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26076       };
26077     } catch (std::exception& e) {
26078       {
26079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26080       };
26081     } catch (Dali::DaliException e) {
26082       {
26083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26084       };
26085     } catch (...) {
26086       {
26087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26088       };
26089     }
26090   }
26091
26092   jresult = new Dali::Shader((const Dali::Shader &)result);
26093
26094   //argout typemap for const std::string&
26095
26096
26097   //argout typemap for const std::string&
26098
26099   return jresult;
26100 }
26101
26102
26103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26104   void * jresult ;
26105   Dali::Shader *result = 0 ;
26106
26107   {
26108     try {
26109       result = (Dali::Shader *)new Dali::Shader();
26110     } catch (std::out_of_range& e) {
26111       {
26112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26113       };
26114     } catch (std::exception& e) {
26115       {
26116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26117       };
26118     } catch (Dali::DaliException e) {
26119       {
26120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26121       };
26122     } catch (...) {
26123       {
26124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26125       };
26126     }
26127   }
26128
26129   jresult = (void *)result;
26130   return jresult;
26131 }
26132
26133
26134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26135   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26136
26137   arg1 = (Dali::Shader *)jarg1;
26138   {
26139     try {
26140       delete arg1;
26141     } catch (std::out_of_range& e) {
26142       {
26143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26144       };
26145     } catch (std::exception& e) {
26146       {
26147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26148       };
26149     } catch (Dali::DaliException e) {
26150       {
26151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26152       };
26153     } catch (...) {
26154       {
26155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26156       };
26157     }
26158   }
26159
26160 }
26161
26162
26163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26164   void * jresult ;
26165   Dali::Shader *arg1 = 0 ;
26166   Dali::Shader *result = 0 ;
26167
26168   arg1 = (Dali::Shader *)jarg1;
26169   if (!arg1) {
26170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26171     return 0;
26172   }
26173   {
26174     try {
26175       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26176     } catch (std::out_of_range& e) {
26177       {
26178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26179       };
26180     } catch (std::exception& e) {
26181       {
26182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26183       };
26184     } catch (Dali::DaliException e) {
26185       {
26186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26187       };
26188     } catch (...) {
26189       {
26190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26191       };
26192     }
26193   }
26194
26195   jresult = (void *)result;
26196   return jresult;
26197 }
26198
26199
26200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26201   void * jresult ;
26202   Dali::BaseHandle arg1 ;
26203   Dali::BaseHandle *argp1 ;
26204   Dali::Shader result;
26205
26206   argp1 = (Dali::BaseHandle *)jarg1;
26207   if (!argp1) {
26208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26209     return 0;
26210   }
26211   arg1 = *argp1;
26212   {
26213     try {
26214       result = Dali::Shader::DownCast(arg1);
26215     } catch (std::out_of_range& e) {
26216       {
26217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26218       };
26219     } catch (std::exception& e) {
26220       {
26221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26222       };
26223     } catch (Dali::DaliException e) {
26224       {
26225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26226       };
26227     } catch (...) {
26228       {
26229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26230       };
26231     }
26232   }
26233
26234   jresult = new Dali::Shader((const Dali::Shader &)result);
26235   return jresult;
26236 }
26237
26238
26239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26240   void * jresult ;
26241   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26242   Dali::Shader *arg2 = 0 ;
26243   Dali::Shader *result = 0 ;
26244
26245   arg1 = (Dali::Shader *)jarg1;
26246   arg2 = (Dali::Shader *)jarg2;
26247   if (!arg2) {
26248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26249     return 0;
26250   }
26251   {
26252     try {
26253       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26254     } catch (std::out_of_range& e) {
26255       {
26256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26257       };
26258     } catch (std::exception& e) {
26259       {
26260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26261       };
26262     } catch (Dali::DaliException e) {
26263       {
26264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26265       };
26266     } catch (...) {
26267       {
26268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26269       };
26270     }
26271   }
26272
26273   jresult = (void *)result;
26274   return jresult;
26275 }
26276
26277
26278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26279   int jresult ;
26280   int result;
26281
26282   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26283   jresult = (int)result;
26284   return jresult;
26285 }
26286
26287
26288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26289   int jresult ;
26290   int result;
26291
26292   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26293   jresult = (int)result;
26294   return jresult;
26295 }
26296
26297
26298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26299   int jresult ;
26300   int result;
26301
26302   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26303   jresult = (int)result;
26304   return jresult;
26305 }
26306
26307
26308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26309   int jresult ;
26310   int result;
26311
26312   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26313   jresult = (int)result;
26314   return jresult;
26315 }
26316
26317
26318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26319   int jresult ;
26320   int result;
26321
26322   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26323   jresult = (int)result;
26324   return jresult;
26325 }
26326
26327
26328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26329   int jresult ;
26330   int result;
26331
26332   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26333   jresult = (int)result;
26334   return jresult;
26335 }
26336
26337
26338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26339   int jresult ;
26340   int result;
26341
26342   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26343   jresult = (int)result;
26344   return jresult;
26345 }
26346
26347
26348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26349   int jresult ;
26350   int result;
26351
26352   result = (int)Dali::Renderer::Property::BLEND_MODE;
26353   jresult = (int)result;
26354   return jresult;
26355 }
26356
26357
26358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26359   int jresult ;
26360   int result;
26361
26362   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26363   jresult = (int)result;
26364   return jresult;
26365 }
26366
26367
26368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26369   int jresult ;
26370   int result;
26371
26372   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26373   jresult = (int)result;
26374   return jresult;
26375 }
26376
26377
26378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26379   int jresult ;
26380   int result;
26381
26382   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26383   jresult = (int)result;
26384   return jresult;
26385 }
26386
26387
26388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26389   int jresult ;
26390   int result;
26391
26392   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26393   jresult = (int)result;
26394   return jresult;
26395 }
26396
26397
26398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26399   int jresult ;
26400   int result;
26401
26402   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26403   jresult = (int)result;
26404   return jresult;
26405 }
26406
26407
26408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26409   int jresult ;
26410   int result;
26411
26412   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26413   jresult = (int)result;
26414   return jresult;
26415 }
26416
26417
26418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26419   int jresult ;
26420   int result;
26421
26422   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26423   jresult = (int)result;
26424   return jresult;
26425 }
26426
26427
26428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26429   int jresult ;
26430   int result;
26431
26432   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26433   jresult = (int)result;
26434   return jresult;
26435 }
26436
26437
26438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26439   int jresult ;
26440   int result;
26441
26442   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26443   jresult = (int)result;
26444   return jresult;
26445 }
26446
26447
26448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26449   int jresult ;
26450   int result;
26451
26452   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26453   jresult = (int)result;
26454   return jresult;
26455 }
26456
26457
26458 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26459   int jresult ;
26460   int result;
26461
26462   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26463   jresult = (int)result;
26464   return jresult;
26465 }
26466
26467
26468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26469   int jresult ;
26470   int result;
26471
26472   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26473   jresult = (int)result;
26474   return jresult;
26475 }
26476
26477
26478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26479   int jresult ;
26480   int result;
26481
26482   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26483   jresult = (int)result;
26484   return jresult;
26485 }
26486
26487
26488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26489   int jresult ;
26490   int result;
26491
26492   result = (int)Dali::Renderer::Property::RENDER_MODE;
26493   jresult = (int)result;
26494   return jresult;
26495 }
26496
26497
26498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26499   int jresult ;
26500   int result;
26501
26502   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26503   jresult = (int)result;
26504   return jresult;
26505 }
26506
26507
26508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26509   int jresult ;
26510   int result;
26511
26512   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26513   jresult = (int)result;
26514   return jresult;
26515 }
26516
26517
26518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26519   int jresult ;
26520   int result;
26521
26522   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26523   jresult = (int)result;
26524   return jresult;
26525 }
26526
26527
26528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26529   int jresult ;
26530   int result;
26531
26532   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26533   jresult = (int)result;
26534   return jresult;
26535 }
26536
26537
26538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26539   int jresult ;
26540   int result;
26541
26542   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26543   jresult = (int)result;
26544   return jresult;
26545 }
26546
26547
26548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26549   int jresult ;
26550   int result;
26551
26552   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26553   jresult = (int)result;
26554   return jresult;
26555 }
26556
26557
26558 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26559   int jresult ;
26560   int result;
26561
26562   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26563   jresult = (int)result;
26564   return jresult;
26565 }
26566
26567
26568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26569   void * jresult ;
26570   Dali::Renderer::Property *result = 0 ;
26571
26572   {
26573     try {
26574       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26575     } catch (std::out_of_range& e) {
26576       {
26577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26578       };
26579     } catch (std::exception& e) {
26580       {
26581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26582       };
26583     } catch (Dali::DaliException e) {
26584       {
26585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26586       };
26587     } catch (...) {
26588       {
26589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26590       };
26591     }
26592   }
26593
26594   jresult = (void *)result;
26595   return jresult;
26596 }
26597
26598
26599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26600   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26601
26602   arg1 = (Dali::Renderer::Property *)jarg1;
26603   {
26604     try {
26605       delete arg1;
26606     } catch (std::out_of_range& e) {
26607       {
26608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26609       };
26610     } catch (std::exception& e) {
26611       {
26612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26613       };
26614     } catch (Dali::DaliException e) {
26615       {
26616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26617       };
26618     } catch (...) {
26619       {
26620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26621       };
26622     }
26623   }
26624
26625 }
26626
26627
26628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26629   void * jresult ;
26630   Dali::Geometry *arg1 = 0 ;
26631   Dali::Shader *arg2 = 0 ;
26632   Dali::Renderer result;
26633
26634   arg1 = (Dali::Geometry *)jarg1;
26635   if (!arg1) {
26636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26637     return 0;
26638   }
26639   arg2 = (Dali::Shader *)jarg2;
26640   if (!arg2) {
26641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26642     return 0;
26643   }
26644   {
26645     try {
26646       result = Dali::Renderer::New(*arg1,*arg2);
26647     } catch (std::out_of_range& e) {
26648       {
26649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26650       };
26651     } catch (std::exception& e) {
26652       {
26653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26654       };
26655     } catch (Dali::DaliException e) {
26656       {
26657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26658       };
26659     } catch (...) {
26660       {
26661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26662       };
26663     }
26664   }
26665
26666   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26667   return jresult;
26668 }
26669
26670
26671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26672   void * jresult ;
26673   Dali::Renderer *result = 0 ;
26674
26675   {
26676     try {
26677       result = (Dali::Renderer *)new Dali::Renderer();
26678     } catch (std::out_of_range& e) {
26679       {
26680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26681       };
26682     } catch (std::exception& e) {
26683       {
26684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26685       };
26686     } catch (Dali::DaliException e) {
26687       {
26688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26689       };
26690     } catch (...) {
26691       {
26692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26693       };
26694     }
26695   }
26696
26697   jresult = (void *)result;
26698   return jresult;
26699 }
26700
26701
26702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26703   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26704
26705   arg1 = (Dali::Renderer *)jarg1;
26706   {
26707     try {
26708       delete arg1;
26709     } catch (std::out_of_range& e) {
26710       {
26711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26712       };
26713     } catch (std::exception& e) {
26714       {
26715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26716       };
26717     } catch (Dali::DaliException e) {
26718       {
26719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26720       };
26721     } catch (...) {
26722       {
26723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26724       };
26725     }
26726   }
26727
26728 }
26729
26730
26731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26732   void * jresult ;
26733   Dali::Renderer *arg1 = 0 ;
26734   Dali::Renderer *result = 0 ;
26735
26736   arg1 = (Dali::Renderer *)jarg1;
26737   if (!arg1) {
26738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26739     return 0;
26740   }
26741   {
26742     try {
26743       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26744     } catch (std::out_of_range& e) {
26745       {
26746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26747       };
26748     } catch (std::exception& e) {
26749       {
26750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26751       };
26752     } catch (Dali::DaliException e) {
26753       {
26754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26755       };
26756     } catch (...) {
26757       {
26758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26759       };
26760     }
26761   }
26762
26763   jresult = (void *)result;
26764   return jresult;
26765 }
26766
26767
26768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26769   void * jresult ;
26770   Dali::BaseHandle arg1 ;
26771   Dali::BaseHandle *argp1 ;
26772   Dali::Renderer result;
26773
26774   argp1 = (Dali::BaseHandle *)jarg1;
26775   if (!argp1) {
26776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26777     return 0;
26778   }
26779   arg1 = *argp1;
26780   {
26781     try {
26782       result = Dali::Renderer::DownCast(arg1);
26783     } catch (std::out_of_range& e) {
26784       {
26785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26786       };
26787     } catch (std::exception& e) {
26788       {
26789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26790       };
26791     } catch (Dali::DaliException e) {
26792       {
26793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26794       };
26795     } catch (...) {
26796       {
26797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26798       };
26799     }
26800   }
26801
26802   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26803   return jresult;
26804 }
26805
26806
26807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
26808   void * jresult ;
26809   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26810   Dali::Renderer *arg2 = 0 ;
26811   Dali::Renderer *result = 0 ;
26812
26813   arg1 = (Dali::Renderer *)jarg1;
26814   arg2 = (Dali::Renderer *)jarg2;
26815   if (!arg2) {
26816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26817     return 0;
26818   }
26819   {
26820     try {
26821       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
26822     } catch (std::out_of_range& e) {
26823       {
26824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26825       };
26826     } catch (std::exception& e) {
26827       {
26828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26829       };
26830     } catch (Dali::DaliException e) {
26831       {
26832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26833       };
26834     } catch (...) {
26835       {
26836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26837       };
26838     }
26839   }
26840
26841   jresult = (void *)result;
26842   return jresult;
26843 }
26844
26845
26846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
26847   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26848   Dali::Geometry *arg2 = 0 ;
26849
26850   arg1 = (Dali::Renderer *)jarg1;
26851   arg2 = (Dali::Geometry *)jarg2;
26852   if (!arg2) {
26853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26854     return ;
26855   }
26856   {
26857     try {
26858       (arg1)->SetGeometry(*arg2);
26859     } catch (std::out_of_range& e) {
26860       {
26861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26862       };
26863     } catch (std::exception& e) {
26864       {
26865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26866       };
26867     } catch (Dali::DaliException e) {
26868       {
26869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26870       };
26871     } catch (...) {
26872       {
26873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26874       };
26875     }
26876   }
26877
26878 }
26879
26880
26881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
26882   void * jresult ;
26883   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26884   Dali::Geometry result;
26885
26886   arg1 = (Dali::Renderer *)jarg1;
26887   {
26888     try {
26889       result = ((Dali::Renderer const *)arg1)->GetGeometry();
26890     } catch (std::out_of_range& e) {
26891       {
26892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26893       };
26894     } catch (std::exception& e) {
26895       {
26896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26897       };
26898     } catch (Dali::DaliException e) {
26899       {
26900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26901       };
26902     } catch (...) {
26903       {
26904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26905       };
26906     }
26907   }
26908
26909   jresult = new Dali::Geometry((const Dali::Geometry &)result);
26910   return jresult;
26911 }
26912
26913
26914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
26915   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26916   int arg2 ;
26917   int arg3 ;
26918
26919   arg1 = (Dali::Renderer *)jarg1;
26920   arg2 = (int)jarg2;
26921   arg3 = (int)jarg3;
26922   {
26923     try {
26924       (arg1)->SetIndexRange(arg2,arg3);
26925     } catch (std::out_of_range& e) {
26926       {
26927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26928       };
26929     } catch (std::exception& e) {
26930       {
26931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26932       };
26933     } catch (Dali::DaliException e) {
26934       {
26935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26936       };
26937     } catch (...) {
26938       {
26939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26940       };
26941     }
26942   }
26943
26944 }
26945
26946
26947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
26948   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26949   Dali::TextureSet *arg2 = 0 ;
26950
26951   arg1 = (Dali::Renderer *)jarg1;
26952   arg2 = (Dali::TextureSet *)jarg2;
26953   if (!arg2) {
26954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
26955     return ;
26956   }
26957   {
26958     try {
26959       (arg1)->SetTextures(*arg2);
26960     } catch (std::out_of_range& e) {
26961       {
26962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26963       };
26964     } catch (std::exception& e) {
26965       {
26966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26967       };
26968     } catch (Dali::DaliException e) {
26969       {
26970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26971       };
26972     } catch (...) {
26973       {
26974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26975       };
26976     }
26977   }
26978
26979 }
26980
26981
26982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
26983   void * jresult ;
26984   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26985   Dali::TextureSet result;
26986
26987   arg1 = (Dali::Renderer *)jarg1;
26988   {
26989     try {
26990       result = ((Dali::Renderer const *)arg1)->GetTextures();
26991     } catch (std::out_of_range& e) {
26992       {
26993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26994       };
26995     } catch (std::exception& e) {
26996       {
26997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26998       };
26999     } catch (Dali::DaliException e) {
27000       {
27001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27002       };
27003     } catch (...) {
27004       {
27005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27006       };
27007     }
27008   }
27009
27010   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27011   return jresult;
27012 }
27013
27014
27015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27016   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27017   Dali::Shader *arg2 = 0 ;
27018
27019   arg1 = (Dali::Renderer *)jarg1;
27020   arg2 = (Dali::Shader *)jarg2;
27021   if (!arg2) {
27022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27023     return ;
27024   }
27025   {
27026     try {
27027       (arg1)->SetShader(*arg2);
27028     } catch (std::out_of_range& e) {
27029       {
27030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27031       };
27032     } catch (std::exception& e) {
27033       {
27034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27035       };
27036     } catch (Dali::DaliException e) {
27037       {
27038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27039       };
27040     } catch (...) {
27041       {
27042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27043       };
27044     }
27045   }
27046
27047 }
27048
27049
27050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27051   void * jresult ;
27052   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27053   Dali::Shader result;
27054
27055   arg1 = (Dali::Renderer *)jarg1;
27056   {
27057     try {
27058       result = ((Dali::Renderer const *)arg1)->GetShader();
27059     } catch (std::out_of_range& e) {
27060       {
27061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27062       };
27063     } catch (std::exception& e) {
27064       {
27065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27066       };
27067     } catch (Dali::DaliException e) {
27068       {
27069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27070       };
27071     } catch (...) {
27072       {
27073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27074       };
27075     }
27076   }
27077
27078   jresult = new Dali::Shader((const Dali::Shader &)result);
27079   return jresult;
27080 }
27081
27082
27083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27084   void * jresult ;
27085   Dali::FrameBuffer::Attachment *result = 0 ;
27086
27087   {
27088     try {
27089       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27090     } catch (std::out_of_range& e) {
27091       {
27092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27093       };
27094     } catch (std::exception& e) {
27095       {
27096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27097       };
27098     } catch (Dali::DaliException e) {
27099       {
27100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27101       };
27102     } catch (...) {
27103       {
27104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27105       };
27106     }
27107   }
27108
27109   jresult = (void *)result;
27110   return jresult;
27111 }
27112
27113
27114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27115   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27116
27117   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27118   {
27119     try {
27120       delete arg1;
27121     } catch (std::out_of_range& e) {
27122       {
27123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27124       };
27125     } catch (std::exception& e) {
27126       {
27127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27128       };
27129     } catch (Dali::DaliException e) {
27130       {
27131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27132       };
27133     } catch (...) {
27134       {
27135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27136       };
27137     }
27138   }
27139
27140 }
27141
27142
27143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27144   void * jresult ;
27145   unsigned int arg1 ;
27146   unsigned int arg2 ;
27147   unsigned int arg3 ;
27148   Dali::FrameBuffer result;
27149
27150   arg1 = (unsigned int)jarg1;
27151   arg2 = (unsigned int)jarg2;
27152   arg3 = (unsigned int)jarg3;
27153   {
27154     try {
27155       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
27156     } catch (std::out_of_range& e) {
27157       {
27158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27159       };
27160     } catch (std::exception& e) {
27161       {
27162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27163       };
27164     } catch (Dali::DaliException e) {
27165       {
27166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27167       };
27168     } catch (...) {
27169       {
27170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27171       };
27172     }
27173   }
27174
27175   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27176   return jresult;
27177 }
27178
27179
27180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27181   void * jresult ;
27182   Dali::FrameBuffer *result = 0 ;
27183
27184   {
27185     try {
27186       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27187     } catch (std::out_of_range& e) {
27188       {
27189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27190       };
27191     } catch (std::exception& e) {
27192       {
27193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27194       };
27195     } catch (Dali::DaliException e) {
27196       {
27197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27198       };
27199     } catch (...) {
27200       {
27201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27202       };
27203     }
27204   }
27205
27206   jresult = (void *)result;
27207   return jresult;
27208 }
27209
27210
27211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27212   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27213
27214   arg1 = (Dali::FrameBuffer *)jarg1;
27215   {
27216     try {
27217       delete arg1;
27218     } catch (std::out_of_range& e) {
27219       {
27220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27221       };
27222     } catch (std::exception& e) {
27223       {
27224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27225       };
27226     } catch (Dali::DaliException e) {
27227       {
27228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27229       };
27230     } catch (...) {
27231       {
27232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27233       };
27234     }
27235   }
27236
27237 }
27238
27239
27240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27241   void * jresult ;
27242   Dali::FrameBuffer *arg1 = 0 ;
27243   Dali::FrameBuffer *result = 0 ;
27244
27245   arg1 = (Dali::FrameBuffer *)jarg1;
27246   if (!arg1) {
27247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27248     return 0;
27249   }
27250   {
27251     try {
27252       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27253     } catch (std::out_of_range& e) {
27254       {
27255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27256       };
27257     } catch (std::exception& e) {
27258       {
27259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27260       };
27261     } catch (Dali::DaliException e) {
27262       {
27263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27264       };
27265     } catch (...) {
27266       {
27267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27268       };
27269     }
27270   }
27271
27272   jresult = (void *)result;
27273   return jresult;
27274 }
27275
27276
27277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27278   void * jresult ;
27279   Dali::BaseHandle arg1 ;
27280   Dali::BaseHandle *argp1 ;
27281   Dali::FrameBuffer result;
27282
27283   argp1 = (Dali::BaseHandle *)jarg1;
27284   if (!argp1) {
27285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27286     return 0;
27287   }
27288   arg1 = *argp1;
27289   {
27290     try {
27291       result = Dali::FrameBuffer::DownCast(arg1);
27292     } catch (std::out_of_range& e) {
27293       {
27294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27295       };
27296     } catch (std::exception& e) {
27297       {
27298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27299       };
27300     } catch (Dali::DaliException e) {
27301       {
27302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27303       };
27304     } catch (...) {
27305       {
27306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27307       };
27308     }
27309   }
27310
27311   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27312   return jresult;
27313 }
27314
27315
27316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27317   void * jresult ;
27318   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27319   Dali::FrameBuffer *arg2 = 0 ;
27320   Dali::FrameBuffer *result = 0 ;
27321
27322   arg1 = (Dali::FrameBuffer *)jarg1;
27323   arg2 = (Dali::FrameBuffer *)jarg2;
27324   if (!arg2) {
27325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27326     return 0;
27327   }
27328   {
27329     try {
27330       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27331     } catch (std::out_of_range& e) {
27332       {
27333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27334       };
27335     } catch (std::exception& e) {
27336       {
27337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27338       };
27339     } catch (Dali::DaliException e) {
27340       {
27341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27342       };
27343     } catch (...) {
27344       {
27345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27346       };
27347     }
27348   }
27349
27350   jresult = (void *)result;
27351   return jresult;
27352 }
27353
27354
27355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27356   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27357   Dali::Texture *arg2 = 0 ;
27358
27359   arg1 = (Dali::FrameBuffer *)jarg1;
27360   arg2 = (Dali::Texture *)jarg2;
27361   if (!arg2) {
27362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27363     return ;
27364   }
27365   {
27366     try {
27367       (arg1)->AttachColorTexture(*arg2);
27368     } catch (std::out_of_range& e) {
27369       {
27370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27371       };
27372     } catch (std::exception& e) {
27373       {
27374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27375       };
27376     } catch (Dali::DaliException e) {
27377       {
27378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27379       };
27380     } catch (...) {
27381       {
27382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27383       };
27384     }
27385   }
27386
27387 }
27388
27389
27390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27391   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27392   Dali::Texture *arg2 = 0 ;
27393   unsigned int arg3 ;
27394   unsigned int arg4 ;
27395
27396   arg1 = (Dali::FrameBuffer *)jarg1;
27397   arg2 = (Dali::Texture *)jarg2;
27398   if (!arg2) {
27399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27400     return ;
27401   }
27402   arg3 = (unsigned int)jarg3;
27403   arg4 = (unsigned int)jarg4;
27404   {
27405     try {
27406       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27407     } catch (std::out_of_range& e) {
27408       {
27409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27410       };
27411     } catch (std::exception& e) {
27412       {
27413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27414       };
27415     } catch (Dali::DaliException e) {
27416       {
27417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27418       };
27419     } catch (...) {
27420       {
27421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27422       };
27423     }
27424   }
27425
27426 }
27427
27428
27429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27430   void * jresult ;
27431   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27432   Dali::Texture result;
27433
27434   arg1 = (Dali::FrameBuffer *)jarg1;
27435   {
27436     try {
27437       result = (arg1)->GetColorTexture();
27438     } catch (std::out_of_range& e) {
27439       {
27440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27441       };
27442     } catch (std::exception& e) {
27443       {
27444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27445       };
27446     } catch (Dali::DaliException e) {
27447       {
27448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27449       };
27450     } catch (...) {
27451       {
27452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27453       };
27454     }
27455   }
27456
27457   jresult = new Dali::Texture((const Dali::Texture &)result);
27458   return jresult;
27459 }
27460
27461
27462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27463   void * jresult ;
27464   Dali::RenderTaskList *result = 0 ;
27465
27466   {
27467     try {
27468       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27469     } catch (std::out_of_range& e) {
27470       {
27471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27472       };
27473     } catch (std::exception& e) {
27474       {
27475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27476       };
27477     } catch (Dali::DaliException e) {
27478       {
27479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27480       };
27481     } catch (...) {
27482       {
27483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27484       };
27485     }
27486   }
27487
27488   jresult = (void *)result;
27489   return jresult;
27490 }
27491
27492
27493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27494   void * jresult ;
27495   Dali::BaseHandle arg1 ;
27496   Dali::BaseHandle *argp1 ;
27497   Dali::RenderTaskList result;
27498
27499   argp1 = (Dali::BaseHandle *)jarg1;
27500   if (!argp1) {
27501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27502     return 0;
27503   }
27504   arg1 = *argp1;
27505   {
27506     try {
27507       result = Dali::RenderTaskList::DownCast(arg1);
27508     } catch (std::out_of_range& e) {
27509       {
27510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27511       };
27512     } catch (std::exception& e) {
27513       {
27514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27515       };
27516     } catch (Dali::DaliException e) {
27517       {
27518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27519       };
27520     } catch (...) {
27521       {
27522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27523       };
27524     }
27525   }
27526
27527   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27528   return jresult;
27529 }
27530
27531
27532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27533   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27534
27535   arg1 = (Dali::RenderTaskList *)jarg1;
27536   {
27537     try {
27538       delete arg1;
27539     } catch (std::out_of_range& e) {
27540       {
27541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27542       };
27543     } catch (std::exception& e) {
27544       {
27545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27546       };
27547     } catch (Dali::DaliException e) {
27548       {
27549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27550       };
27551     } catch (...) {
27552       {
27553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27554       };
27555     }
27556   }
27557
27558 }
27559
27560
27561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27562   void * jresult ;
27563   Dali::RenderTaskList *arg1 = 0 ;
27564   Dali::RenderTaskList *result = 0 ;
27565
27566   arg1 = (Dali::RenderTaskList *)jarg1;
27567   if (!arg1) {
27568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27569     return 0;
27570   }
27571   {
27572     try {
27573       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27574     } catch (std::out_of_range& e) {
27575       {
27576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27577       };
27578     } catch (std::exception& e) {
27579       {
27580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27581       };
27582     } catch (Dali::DaliException e) {
27583       {
27584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27585       };
27586     } catch (...) {
27587       {
27588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27589       };
27590     }
27591   }
27592
27593   jresult = (void *)result;
27594   return jresult;
27595 }
27596
27597
27598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27599   void * jresult ;
27600   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27601   Dali::RenderTaskList *arg2 = 0 ;
27602   Dali::RenderTaskList *result = 0 ;
27603
27604   arg1 = (Dali::RenderTaskList *)jarg1;
27605   arg2 = (Dali::RenderTaskList *)jarg2;
27606   if (!arg2) {
27607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27608     return 0;
27609   }
27610   {
27611     try {
27612       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27613     } catch (std::out_of_range& e) {
27614       {
27615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27616       };
27617     } catch (std::exception& e) {
27618       {
27619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27620       };
27621     } catch (Dali::DaliException e) {
27622       {
27623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27624       };
27625     } catch (...) {
27626       {
27627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27628       };
27629     }
27630   }
27631
27632   jresult = (void *)result;
27633   return jresult;
27634 }
27635
27636
27637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27638   void * jresult ;
27639   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27640   Dali::RenderTask result;
27641
27642   arg1 = (Dali::RenderTaskList *)jarg1;
27643   {
27644     try {
27645       result = (arg1)->CreateTask();
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 = new Dali::RenderTask((const Dali::RenderTask &)result);
27666   return jresult;
27667 }
27668
27669
27670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27671   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27672   Dali::RenderTask arg2 ;
27673   Dali::RenderTask *argp2 ;
27674
27675   arg1 = (Dali::RenderTaskList *)jarg1;
27676   argp2 = (Dali::RenderTask *)jarg2;
27677   if (!argp2) {
27678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27679     return ;
27680   }
27681   arg2 = *argp2;
27682   {
27683     try {
27684       (arg1)->RemoveTask(arg2);
27685     } catch (std::out_of_range& e) {
27686       {
27687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27688       };
27689     } catch (std::exception& e) {
27690       {
27691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27692       };
27693     } catch (Dali::DaliException e) {
27694       {
27695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27696       };
27697     } catch (...) {
27698       {
27699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27700       };
27701     }
27702   }
27703
27704 }
27705
27706
27707 //// ===============================================end part 1 =================
27708
27709 //// ========================= part 2 ===============================
27710
27711 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27712   unsigned int jresult ;
27713   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27714   unsigned int result;
27715
27716   arg1 = (Dali::RenderTaskList *)jarg1;
27717   {
27718     try {
27719       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27720     } catch (std::out_of_range& e) {
27721       {
27722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27723       };
27724     } catch (std::exception& e) {
27725       {
27726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27727       };
27728     } catch (Dali::DaliException e) {
27729       {
27730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27731       };
27732     } catch (...) {
27733       {
27734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27735       };
27736     }
27737   }
27738
27739   jresult = result;
27740   return jresult;
27741 }
27742
27743
27744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27745   void * jresult ;
27746   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27747   unsigned int arg2 ;
27748   Dali::RenderTask result;
27749
27750   arg1 = (Dali::RenderTaskList *)jarg1;
27751   arg2 = (unsigned int)jarg2;
27752   {
27753     try {
27754       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27755     } catch (std::out_of_range& e) {
27756       {
27757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27758       };
27759     } catch (std::exception& e) {
27760       {
27761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27762       };
27763     } catch (Dali::DaliException e) {
27764       {
27765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27766       };
27767     } catch (...) {
27768       {
27769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27770       };
27771     }
27772   }
27773
27774   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27775   return jresult;
27776 }
27777
27778
27779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27780   int jresult ;
27781   int result;
27782
27783   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27784   jresult = (int)result;
27785   return jresult;
27786 }
27787
27788
27789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27790   int jresult ;
27791   int result;
27792
27793   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27794   jresult = (int)result;
27795   return jresult;
27796 }
27797
27798
27799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27800   int jresult ;
27801   int result;
27802
27803   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
27804   jresult = (int)result;
27805   return jresult;
27806 }
27807
27808
27809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
27810   int jresult ;
27811   int result;
27812
27813   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
27814   jresult = (int)result;
27815   return jresult;
27816 }
27817
27818
27819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
27820   void * jresult ;
27821   Dali::RenderTask::Property *result = 0 ;
27822
27823   {
27824     try {
27825       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
27826     } catch (std::out_of_range& e) {
27827       {
27828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27829       };
27830     } catch (std::exception& e) {
27831       {
27832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27833       };
27834     } catch (Dali::DaliException e) {
27835       {
27836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27837       };
27838     } catch (...) {
27839       {
27840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27841       };
27842     }
27843   }
27844
27845   jresult = (void *)result;
27846   return jresult;
27847 }
27848
27849
27850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
27851   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
27852
27853   arg1 = (Dali::RenderTask::Property *)jarg1;
27854   {
27855     try {
27856       delete arg1;
27857     } catch (std::out_of_range& e) {
27858       {
27859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27860       };
27861     } catch (std::exception& e) {
27862       {
27863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27864       };
27865     } catch (Dali::DaliException e) {
27866       {
27867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27868       };
27869     } catch (...) {
27870       {
27871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27872       };
27873     }
27874   }
27875
27876 }
27877
27878
27879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
27880   void * jresult ;
27881   bool (*result)(Dali::Vector2 &) = 0 ;
27882
27883   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
27884   jresult = (void *)result;
27885   return jresult;
27886 }
27887
27888
27889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
27890   void * jresult ;
27891   bool (*result)(Dali::Vector2 &) = 0 ;
27892
27893   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
27894   jresult = (void *)result;
27895   return jresult;
27896 }
27897
27898
27899 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
27900   unsigned int jresult ;
27901   bool result;
27902
27903   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
27904   jresult = result;
27905   return jresult;
27906 }
27907
27908
27909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
27910   unsigned int jresult ;
27911   bool result;
27912
27913   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
27914   jresult = result;
27915   return jresult;
27916 }
27917
27918
27919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
27920   void * jresult ;
27921   Dali::Vector4 *result = 0 ;
27922
27923   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
27924   jresult = (void *)result;
27925   return jresult;
27926 }
27927
27928
27929 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
27930   unsigned int jresult ;
27931   bool result;
27932
27933   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
27934   jresult = result;
27935   return jresult;
27936 }
27937
27938
27939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
27940   unsigned int jresult ;
27941   bool result;
27942
27943   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
27944   jresult = result;
27945   return jresult;
27946 }
27947
27948
27949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
27950   unsigned int jresult ;
27951   unsigned int result;
27952
27953   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
27954   jresult = result;
27955   return jresult;
27956 }
27957
27958
27959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
27960   void * jresult ;
27961   Dali::RenderTask *result = 0 ;
27962
27963   {
27964     try {
27965       result = (Dali::RenderTask *)new Dali::RenderTask();
27966     } catch (std::out_of_range& e) {
27967       {
27968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27969       };
27970     } catch (std::exception& e) {
27971       {
27972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27973       };
27974     } catch (Dali::DaliException e) {
27975       {
27976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27977       };
27978     } catch (...) {
27979       {
27980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27981       };
27982     }
27983   }
27984
27985   jresult = (void *)result;
27986   return jresult;
27987 }
27988
27989
27990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
27991   void * jresult ;
27992   Dali::BaseHandle arg1 ;
27993   Dali::BaseHandle *argp1 ;
27994   Dali::RenderTask result;
27995
27996   argp1 = (Dali::BaseHandle *)jarg1;
27997   if (!argp1) {
27998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27999     return 0;
28000   }
28001   arg1 = *argp1;
28002   {
28003     try {
28004       result = Dali::RenderTask::DownCast(arg1);
28005     } catch (std::out_of_range& e) {
28006       {
28007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28008       };
28009     } catch (std::exception& e) {
28010       {
28011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28012       };
28013     } catch (Dali::DaliException e) {
28014       {
28015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28016       };
28017     } catch (...) {
28018       {
28019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28020       };
28021     }
28022   }
28023
28024   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28025   return jresult;
28026 }
28027
28028
28029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28030   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28031
28032   arg1 = (Dali::RenderTask *)jarg1;
28033   {
28034     try {
28035       delete arg1;
28036     } catch (std::out_of_range& e) {
28037       {
28038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28039       };
28040     } catch (std::exception& e) {
28041       {
28042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28043       };
28044     } catch (Dali::DaliException e) {
28045       {
28046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28047       };
28048     } catch (...) {
28049       {
28050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28051       };
28052     }
28053   }
28054
28055 }
28056
28057
28058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28059   void * jresult ;
28060   Dali::RenderTask *arg1 = 0 ;
28061   Dali::RenderTask *result = 0 ;
28062
28063   arg1 = (Dali::RenderTask *)jarg1;
28064   if (!arg1) {
28065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28066     return 0;
28067   }
28068   {
28069     try {
28070       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28071     } catch (std::out_of_range& e) {
28072       {
28073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28074       };
28075     } catch (std::exception& e) {
28076       {
28077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28078       };
28079     } catch (Dali::DaliException e) {
28080       {
28081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28082       };
28083     } catch (...) {
28084       {
28085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28086       };
28087     }
28088   }
28089
28090   jresult = (void *)result;
28091   return jresult;
28092 }
28093
28094
28095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28096   void * jresult ;
28097   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28098   Dali::RenderTask *arg2 = 0 ;
28099   Dali::RenderTask *result = 0 ;
28100
28101   arg1 = (Dali::RenderTask *)jarg1;
28102   arg2 = (Dali::RenderTask *)jarg2;
28103   if (!arg2) {
28104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28105     return 0;
28106   }
28107   {
28108     try {
28109       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28110     } catch (std::out_of_range& e) {
28111       {
28112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28113       };
28114     } catch (std::exception& e) {
28115       {
28116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28117       };
28118     } catch (Dali::DaliException e) {
28119       {
28120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28121       };
28122     } catch (...) {
28123       {
28124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28125       };
28126     }
28127   }
28128
28129   jresult = (void *)result;
28130   return jresult;
28131 }
28132
28133
28134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28135   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28136   Dali::Actor arg2 ;
28137   Dali::Actor *argp2 ;
28138
28139   arg1 = (Dali::RenderTask *)jarg1;
28140   argp2 = (Dali::Actor *)jarg2;
28141   if (!argp2) {
28142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28143     return ;
28144   }
28145   arg2 = *argp2;
28146   {
28147     try {
28148       (arg1)->SetSourceActor(arg2);
28149     } catch (std::out_of_range& e) {
28150       {
28151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28152       };
28153     } catch (std::exception& e) {
28154       {
28155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28156       };
28157     } catch (Dali::DaliException e) {
28158       {
28159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28160       };
28161     } catch (...) {
28162       {
28163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28164       };
28165     }
28166   }
28167
28168 }
28169
28170
28171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28172   void * jresult ;
28173   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28174   Dali::Actor result;
28175
28176   arg1 = (Dali::RenderTask *)jarg1;
28177   {
28178     try {
28179       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28180     } catch (std::out_of_range& e) {
28181       {
28182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28183       };
28184     } catch (std::exception& e) {
28185       {
28186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28187       };
28188     } catch (Dali::DaliException e) {
28189       {
28190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28191       };
28192     } catch (...) {
28193       {
28194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28195       };
28196     }
28197   }
28198
28199   jresult = new Dali::Actor((const Dali::Actor &)result);
28200   return jresult;
28201 }
28202
28203
28204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28205   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28206   bool arg2 ;
28207
28208   arg1 = (Dali::RenderTask *)jarg1;
28209   arg2 = jarg2 ? true : false;
28210   {
28211     try {
28212       (arg1)->SetExclusive(arg2);
28213     } catch (std::out_of_range& e) {
28214       {
28215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28216       };
28217     } catch (std::exception& e) {
28218       {
28219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28220       };
28221     } catch (Dali::DaliException e) {
28222       {
28223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28224       };
28225     } catch (...) {
28226       {
28227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28228       };
28229     }
28230   }
28231
28232 }
28233
28234
28235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28236   unsigned int jresult ;
28237   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28238   bool result;
28239
28240   arg1 = (Dali::RenderTask *)jarg1;
28241   {
28242     try {
28243       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28244     } catch (std::out_of_range& e) {
28245       {
28246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28247       };
28248     } catch (std::exception& e) {
28249       {
28250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28251       };
28252     } catch (Dali::DaliException e) {
28253       {
28254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28255       };
28256     } catch (...) {
28257       {
28258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28259       };
28260     }
28261   }
28262
28263   jresult = result;
28264   return jresult;
28265 }
28266
28267
28268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28269   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28270   bool arg2 ;
28271
28272   arg1 = (Dali::RenderTask *)jarg1;
28273   arg2 = jarg2 ? true : false;
28274   {
28275     try {
28276       (arg1)->SetInputEnabled(arg2);
28277     } catch (std::out_of_range& e) {
28278       {
28279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28280       };
28281     } catch (std::exception& e) {
28282       {
28283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28284       };
28285     } catch (Dali::DaliException e) {
28286       {
28287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28288       };
28289     } catch (...) {
28290       {
28291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28292       };
28293     }
28294   }
28295
28296 }
28297
28298
28299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28300   unsigned int jresult ;
28301   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28302   bool result;
28303
28304   arg1 = (Dali::RenderTask *)jarg1;
28305   {
28306     try {
28307       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28308     } catch (std::out_of_range& e) {
28309       {
28310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28311       };
28312     } catch (std::exception& e) {
28313       {
28314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28315       };
28316     } catch (Dali::DaliException e) {
28317       {
28318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28319       };
28320     } catch (...) {
28321       {
28322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28323       };
28324     }
28325   }
28326
28327   jresult = result;
28328   return jresult;
28329 }
28330
28331
28332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28333   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28334   Dali::CameraActor arg2 ;
28335   Dali::CameraActor *argp2 ;
28336
28337   arg1 = (Dali::RenderTask *)jarg1;
28338   argp2 = (Dali::CameraActor *)jarg2;
28339   if (!argp2) {
28340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28341     return ;
28342   }
28343   arg2 = *argp2;
28344   {
28345     try {
28346       (arg1)->SetCameraActor(arg2);
28347     } catch (std::out_of_range& e) {
28348       {
28349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28350       };
28351     } catch (std::exception& e) {
28352       {
28353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28354       };
28355     } catch (Dali::DaliException e) {
28356       {
28357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28358       };
28359     } catch (...) {
28360       {
28361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28362       };
28363     }
28364   }
28365
28366 }
28367
28368
28369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28370   void * jresult ;
28371   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28372   Dali::CameraActor result;
28373
28374   arg1 = (Dali::RenderTask *)jarg1;
28375   {
28376     try {
28377       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28378     } catch (std::out_of_range& e) {
28379       {
28380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28381       };
28382     } catch (std::exception& e) {
28383       {
28384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28385       };
28386     } catch (Dali::DaliException e) {
28387       {
28388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28389       };
28390     } catch (...) {
28391       {
28392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28393       };
28394     }
28395   }
28396
28397   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28398   return jresult;
28399 }
28400
28401
28402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28403   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28404   Dali::FrameBuffer arg2 ;
28405   Dali::FrameBuffer *argp2 ;
28406
28407   arg1 = (Dali::RenderTask *)jarg1;
28408   argp2 = (Dali::FrameBuffer *)jarg2;
28409   if (!argp2) {
28410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28411     return ;
28412   }
28413   arg2 = *argp2;
28414   {
28415     try {
28416       (arg1)->SetFrameBuffer(arg2);
28417     } catch (std::out_of_range& e) {
28418       {
28419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28420       };
28421     } catch (std::exception& e) {
28422       {
28423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28424       };
28425     } catch (Dali::DaliException e) {
28426       {
28427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28428       };
28429     } catch (...) {
28430       {
28431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28432       };
28433     }
28434   }
28435
28436 }
28437
28438
28439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28440   void * jresult ;
28441   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28442   Dali::FrameBuffer result;
28443
28444   arg1 = (Dali::RenderTask *)jarg1;
28445   {
28446     try {
28447       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28448     } catch (std::out_of_range& e) {
28449       {
28450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28451       };
28452     } catch (std::exception& e) {
28453       {
28454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28455       };
28456     } catch (Dali::DaliException e) {
28457       {
28458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28459       };
28460     } catch (...) {
28461       {
28462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28463       };
28464     }
28465   }
28466
28467   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28468   return jresult;
28469 }
28470
28471
28472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28473   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28474   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28475
28476   arg1 = (Dali::RenderTask *)jarg1;
28477   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28478   {
28479     try {
28480       (arg1)->SetScreenToFrameBufferFunction(arg2);
28481     } catch (std::out_of_range& e) {
28482       {
28483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28484       };
28485     } catch (std::exception& e) {
28486       {
28487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28488       };
28489     } catch (Dali::DaliException e) {
28490       {
28491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28492       };
28493     } catch (...) {
28494       {
28495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28496       };
28497     }
28498   }
28499
28500 }
28501
28502
28503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28504   void * jresult ;
28505   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28506   Dali::RenderTask::ScreenToFrameBufferFunction result;
28507
28508   arg1 = (Dali::RenderTask *)jarg1;
28509   {
28510     try {
28511       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28512     } catch (std::out_of_range& e) {
28513       {
28514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28515       };
28516     } catch (std::exception& e) {
28517       {
28518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28519       };
28520     } catch (Dali::DaliException e) {
28521       {
28522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28523       };
28524     } catch (...) {
28525       {
28526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28527       };
28528     }
28529   }
28530
28531   jresult = (void *)result;
28532   return jresult;
28533 }
28534
28535
28536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28537   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28538   Dali::Actor arg2 ;
28539   Dali::Actor *argp2 ;
28540
28541   arg1 = (Dali::RenderTask *)jarg1;
28542   argp2 = (Dali::Actor *)jarg2;
28543   if (!argp2) {
28544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28545     return ;
28546   }
28547   arg2 = *argp2;
28548   {
28549     try {
28550       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28551     } catch (std::out_of_range& e) {
28552       {
28553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28554       };
28555     } catch (std::exception& e) {
28556       {
28557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28558       };
28559     } catch (Dali::DaliException e) {
28560       {
28561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28562       };
28563     } catch (...) {
28564       {
28565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28566       };
28567     }
28568   }
28569
28570 }
28571
28572
28573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28574   void * jresult ;
28575   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28576   Dali::Actor result;
28577
28578   arg1 = (Dali::RenderTask *)jarg1;
28579   {
28580     try {
28581       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28582     } catch (std::out_of_range& e) {
28583       {
28584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28585       };
28586     } catch (std::exception& e) {
28587       {
28588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28589       };
28590     } catch (Dali::DaliException e) {
28591       {
28592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28593       };
28594     } catch (...) {
28595       {
28596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28597       };
28598     }
28599   }
28600
28601   jresult = new Dali::Actor((const Dali::Actor &)result);
28602   return jresult;
28603 }
28604
28605
28606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28607   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28608   Dali::Vector2 arg2 ;
28609   Dali::Vector2 *argp2 ;
28610
28611   arg1 = (Dali::RenderTask *)jarg1;
28612   argp2 = (Dali::Vector2 *)jarg2;
28613   if (!argp2) {
28614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28615     return ;
28616   }
28617   arg2 = *argp2;
28618   {
28619     try {
28620       (arg1)->SetViewportPosition(arg2);
28621     } catch (std::out_of_range& e) {
28622       {
28623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28624       };
28625     } catch (std::exception& e) {
28626       {
28627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28628       };
28629     } catch (Dali::DaliException e) {
28630       {
28631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28632       };
28633     } catch (...) {
28634       {
28635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28636       };
28637     }
28638   }
28639
28640 }
28641
28642
28643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28644   void * jresult ;
28645   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28646   Dali::Vector2 result;
28647
28648   arg1 = (Dali::RenderTask *)jarg1;
28649   {
28650     try {
28651       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28652     } catch (std::out_of_range& e) {
28653       {
28654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28655       };
28656     } catch (std::exception& e) {
28657       {
28658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28659       };
28660     } catch (Dali::DaliException e) {
28661       {
28662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28663       };
28664     } catch (...) {
28665       {
28666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28667       };
28668     }
28669   }
28670
28671   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28672   return jresult;
28673 }
28674
28675
28676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28677   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28678   Dali::Vector2 arg2 ;
28679   Dali::Vector2 *argp2 ;
28680
28681   arg1 = (Dali::RenderTask *)jarg1;
28682   argp2 = (Dali::Vector2 *)jarg2;
28683   if (!argp2) {
28684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28685     return ;
28686   }
28687   arg2 = *argp2;
28688   {
28689     try {
28690       (arg1)->SetViewportSize(arg2);
28691     } catch (std::out_of_range& e) {
28692       {
28693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28694       };
28695     } catch (std::exception& e) {
28696       {
28697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28698       };
28699     } catch (Dali::DaliException e) {
28700       {
28701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28702       };
28703     } catch (...) {
28704       {
28705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28706       };
28707     }
28708   }
28709
28710 }
28711
28712
28713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28714   void * jresult ;
28715   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28716   Dali::Vector2 result;
28717
28718   arg1 = (Dali::RenderTask *)jarg1;
28719   {
28720     try {
28721       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28722     } catch (std::out_of_range& e) {
28723       {
28724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28725       };
28726     } catch (std::exception& e) {
28727       {
28728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28729       };
28730     } catch (Dali::DaliException e) {
28731       {
28732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28733       };
28734     } catch (...) {
28735       {
28736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28737       };
28738     }
28739   }
28740
28741   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28742   return jresult;
28743 }
28744
28745
28746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
28747   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28748   Dali::Viewport arg2 ;
28749   Dali::Viewport *argp2 ;
28750
28751   arg1 = (Dali::RenderTask *)jarg1;
28752   argp2 = (Dali::Viewport *)jarg2;
28753   if (!argp2) {
28754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
28755     return ;
28756   }
28757   arg2 = *argp2;
28758   {
28759     try {
28760       (arg1)->SetViewport(arg2);
28761     } catch (std::out_of_range& e) {
28762       {
28763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28764       };
28765     } catch (std::exception& e) {
28766       {
28767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28768       };
28769     } catch (Dali::DaliException e) {
28770       {
28771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28772       };
28773     } catch (...) {
28774       {
28775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28776       };
28777     }
28778   }
28779
28780 }
28781
28782
28783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
28784   void * jresult ;
28785   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28786   Dali::Viewport result;
28787
28788   arg1 = (Dali::RenderTask *)jarg1;
28789   {
28790     try {
28791       result = ((Dali::RenderTask const *)arg1)->GetViewport();
28792     } catch (std::out_of_range& e) {
28793       {
28794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28795       };
28796     } catch (std::exception& e) {
28797       {
28798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28799       };
28800     } catch (Dali::DaliException e) {
28801       {
28802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28803       };
28804     } catch (...) {
28805       {
28806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28807       };
28808     }
28809   }
28810
28811   jresult = new Dali::Viewport((const Dali::Viewport &)result);
28812   return jresult;
28813 }
28814
28815
28816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
28817   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28818   Dali::Vector4 *arg2 = 0 ;
28819
28820   arg1 = (Dali::RenderTask *)jarg1;
28821   arg2 = (Dali::Vector4 *)jarg2;
28822   if (!arg2) {
28823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
28824     return ;
28825   }
28826   {
28827     try {
28828       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
28829     } catch (std::out_of_range& e) {
28830       {
28831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28832       };
28833     } catch (std::exception& e) {
28834       {
28835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28836       };
28837     } catch (Dali::DaliException e) {
28838       {
28839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28840       };
28841     } catch (...) {
28842       {
28843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28844       };
28845     }
28846   }
28847
28848 }
28849
28850
28851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
28852   void * jresult ;
28853   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28854   Dali::Vector4 result;
28855
28856   arg1 = (Dali::RenderTask *)jarg1;
28857   {
28858     try {
28859       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
28860     } catch (std::out_of_range& e) {
28861       {
28862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28863       };
28864     } catch (std::exception& e) {
28865       {
28866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28867       };
28868     } catch (Dali::DaliException e) {
28869       {
28870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28871       };
28872     } catch (...) {
28873       {
28874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28875       };
28876     }
28877   }
28878
28879   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
28880   return jresult;
28881 }
28882
28883
28884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
28885   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28886   bool arg2 ;
28887
28888   arg1 = (Dali::RenderTask *)jarg1;
28889   arg2 = jarg2 ? true : false;
28890   {
28891     try {
28892       (arg1)->SetClearEnabled(arg2);
28893     } catch (std::out_of_range& e) {
28894       {
28895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28896       };
28897     } catch (std::exception& e) {
28898       {
28899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28900       };
28901     } catch (Dali::DaliException e) {
28902       {
28903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28904       };
28905     } catch (...) {
28906       {
28907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28908       };
28909     }
28910   }
28911
28912 }
28913
28914
28915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
28916   unsigned int jresult ;
28917   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28918   bool result;
28919
28920   arg1 = (Dali::RenderTask *)jarg1;
28921   {
28922     try {
28923       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
28924     } catch (std::out_of_range& e) {
28925       {
28926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28927       };
28928     } catch (std::exception& e) {
28929       {
28930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28931       };
28932     } catch (Dali::DaliException e) {
28933       {
28934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28935       };
28936     } catch (...) {
28937       {
28938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28939       };
28940     }
28941   }
28942
28943   jresult = result;
28944   return jresult;
28945 }
28946
28947
28948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
28949   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28950   bool arg2 ;
28951
28952   arg1 = (Dali::RenderTask *)jarg1;
28953   arg2 = jarg2 ? true : false;
28954   {
28955     try {
28956       (arg1)->SetCullMode(arg2);
28957     } catch (std::out_of_range& e) {
28958       {
28959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28960       };
28961     } catch (std::exception& e) {
28962       {
28963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28964       };
28965     } catch (Dali::DaliException e) {
28966       {
28967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28968       };
28969     } catch (...) {
28970       {
28971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28972       };
28973     }
28974   }
28975
28976 }
28977
28978
28979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
28980   unsigned int jresult ;
28981   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28982   bool result;
28983
28984   arg1 = (Dali::RenderTask *)jarg1;
28985   {
28986     try {
28987       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
28988     } catch (std::out_of_range& e) {
28989       {
28990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28991       };
28992     } catch (std::exception& e) {
28993       {
28994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28995       };
28996     } catch (Dali::DaliException e) {
28997       {
28998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28999       };
29000     } catch (...) {
29001       {
29002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29003       };
29004     }
29005   }
29006
29007   jresult = result;
29008   return jresult;
29009 }
29010
29011
29012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29013   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29014   unsigned int arg2 ;
29015
29016   arg1 = (Dali::RenderTask *)jarg1;
29017   arg2 = (unsigned int)jarg2;
29018   {
29019     try {
29020       (arg1)->SetRefreshRate(arg2);
29021     } catch (std::out_of_range& e) {
29022       {
29023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29024       };
29025     } catch (std::exception& e) {
29026       {
29027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29028       };
29029     } catch (Dali::DaliException e) {
29030       {
29031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29032       };
29033     } catch (...) {
29034       {
29035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29036       };
29037     }
29038   }
29039
29040 }
29041
29042
29043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29044   unsigned int jresult ;
29045   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29046   unsigned int result;
29047
29048   arg1 = (Dali::RenderTask *)jarg1;
29049   {
29050     try {
29051       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29052     } catch (std::out_of_range& e) {
29053       {
29054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29055       };
29056     } catch (std::exception& e) {
29057       {
29058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29059       };
29060     } catch (Dali::DaliException e) {
29061       {
29062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29063       };
29064     } catch (...) {
29065       {
29066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29067       };
29068     }
29069   }
29070
29071   jresult = result;
29072   return jresult;
29073 }
29074
29075
29076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29077   unsigned int jresult ;
29078   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29079   Dali::Vector3 *arg2 = 0 ;
29080   float *arg3 = 0 ;
29081   float *arg4 = 0 ;
29082   bool result;
29083
29084   arg1 = (Dali::RenderTask *)jarg1;
29085   arg2 = (Dali::Vector3 *)jarg2;
29086   if (!arg2) {
29087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29088     return 0;
29089   }
29090   arg3 = (float *)jarg3;
29091   arg4 = (float *)jarg4;
29092   {
29093     try {
29094       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29095     } catch (std::out_of_range& e) {
29096       {
29097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29098       };
29099     } catch (std::exception& e) {
29100       {
29101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29102       };
29103     } catch (Dali::DaliException e) {
29104       {
29105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29106       };
29107     } catch (...) {
29108       {
29109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29110       };
29111     }
29112   }
29113
29114   jresult = result;
29115   return jresult;
29116 }
29117
29118
29119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29120   unsigned int jresult ;
29121   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29122   Dali::Actor arg2 ;
29123   float arg3 ;
29124   float arg4 ;
29125   float *arg5 = 0 ;
29126   float *arg6 = 0 ;
29127   Dali::Actor *argp2 ;
29128   bool result;
29129
29130   arg1 = (Dali::RenderTask *)jarg1;
29131   argp2 = (Dali::Actor *)jarg2;
29132   if (!argp2) {
29133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29134     return 0;
29135   }
29136   arg2 = *argp2;
29137   arg3 = (float)jarg3;
29138   arg4 = (float)jarg4;
29139   arg5 = (float *)jarg5;
29140   arg6 = (float *)jarg6;
29141   {
29142     try {
29143       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29144     } catch (std::out_of_range& e) {
29145       {
29146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29147       };
29148     } catch (std::exception& e) {
29149       {
29150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29151       };
29152     } catch (Dali::DaliException e) {
29153       {
29154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29155       };
29156     } catch (...) {
29157       {
29158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29159       };
29160     }
29161   }
29162
29163   jresult = result;
29164   return jresult;
29165 }
29166
29167
29168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29169   void * jresult ;
29170   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29171   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29172
29173   arg1 = (Dali::RenderTask *)jarg1;
29174   {
29175     try {
29176       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
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 = (void *)result;
29197   return jresult;
29198 }
29199
29200
29201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29202   void * jresult ;
29203   int arg1 ;
29204   Dali::TouchPoint::State arg2 ;
29205   float arg3 ;
29206   float arg4 ;
29207   Dali::TouchPoint *result = 0 ;
29208
29209   arg1 = (int)jarg1;
29210   arg2 = (Dali::TouchPoint::State)jarg2;
29211   arg3 = (float)jarg3;
29212   arg4 = (float)jarg4;
29213   {
29214     try {
29215       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29216     } catch (std::out_of_range& e) {
29217       {
29218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29219       };
29220     } catch (std::exception& e) {
29221       {
29222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29223       };
29224     } catch (Dali::DaliException e) {
29225       {
29226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29227       };
29228     } catch (...) {
29229       {
29230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29231       };
29232     }
29233   }
29234
29235   jresult = (void *)result;
29236   return jresult;
29237 }
29238
29239
29240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29241   void * jresult ;
29242   int arg1 ;
29243   Dali::TouchPoint::State arg2 ;
29244   float arg3 ;
29245   float arg4 ;
29246   float arg5 ;
29247   float arg6 ;
29248   Dali::TouchPoint *result = 0 ;
29249
29250   arg1 = (int)jarg1;
29251   arg2 = (Dali::TouchPoint::State)jarg2;
29252   arg3 = (float)jarg3;
29253   arg4 = (float)jarg4;
29254   arg5 = (float)jarg5;
29255   arg6 = (float)jarg6;
29256   {
29257     try {
29258       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29259     } catch (std::out_of_range& e) {
29260       {
29261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29262       };
29263     } catch (std::exception& e) {
29264       {
29265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29266       };
29267     } catch (Dali::DaliException e) {
29268       {
29269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29270       };
29271     } catch (...) {
29272       {
29273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29274       };
29275     }
29276   }
29277
29278   jresult = (void *)result;
29279   return jresult;
29280 }
29281
29282
29283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29284   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29285
29286   arg1 = (Dali::TouchPoint *)jarg1;
29287   {
29288     try {
29289       delete arg1;
29290     } catch (std::out_of_range& e) {
29291       {
29292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29293       };
29294     } catch (std::exception& e) {
29295       {
29296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29297       };
29298     } catch (Dali::DaliException e) {
29299       {
29300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29301       };
29302     } catch (...) {
29303       {
29304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29305       };
29306     }
29307   }
29308
29309 }
29310
29311
29312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29313   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29314   int arg2 ;
29315
29316   arg1 = (Dali::TouchPoint *)jarg1;
29317   arg2 = (int)jarg2;
29318   if (arg1) (arg1)->deviceId = arg2;
29319 }
29320
29321
29322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29323   int jresult ;
29324   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29325   int result;
29326
29327   arg1 = (Dali::TouchPoint *)jarg1;
29328   result = (int) ((arg1)->deviceId);
29329   jresult = result;
29330   return jresult;
29331 }
29332
29333
29334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29335   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29336   Dali::TouchPoint::State arg2 ;
29337
29338   arg1 = (Dali::TouchPoint *)jarg1;
29339   arg2 = (Dali::TouchPoint::State)jarg2;
29340   if (arg1) (arg1)->state = arg2;
29341 }
29342
29343
29344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29345   int jresult ;
29346   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29347   Dali::TouchPoint::State result;
29348
29349   arg1 = (Dali::TouchPoint *)jarg1;
29350   result = (Dali::TouchPoint::State) ((arg1)->state);
29351   jresult = (int)result;
29352   return jresult;
29353 }
29354
29355
29356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29357   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29358   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29359
29360   arg1 = (Dali::TouchPoint *)jarg1;
29361   arg2 = (Dali::Actor *)jarg2;
29362   if (arg1) (arg1)->hitActor = *arg2;
29363 }
29364
29365
29366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29367   void * jresult ;
29368   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29369   Dali::Actor *result = 0 ;
29370
29371   arg1 = (Dali::TouchPoint *)jarg1;
29372   result = (Dali::Actor *)& ((arg1)->hitActor);
29373   jresult = (void *)result;
29374   return jresult;
29375 }
29376
29377
29378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29379   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29380   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29381
29382   arg1 = (Dali::TouchPoint *)jarg1;
29383   arg2 = (Dali::Vector2 *)jarg2;
29384   if (arg1) (arg1)->local = *arg2;
29385 }
29386
29387
29388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29389   void * jresult ;
29390   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29391   Dali::Vector2 *result = 0 ;
29392
29393   arg1 = (Dali::TouchPoint *)jarg1;
29394   result = (Dali::Vector2 *)& ((arg1)->local);
29395   jresult = (void *)result;
29396   return jresult;
29397 }
29398
29399
29400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29401   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29402   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29403
29404   arg1 = (Dali::TouchPoint *)jarg1;
29405   arg2 = (Dali::Vector2 *)jarg2;
29406   if (arg1) (arg1)->screen = *arg2;
29407 }
29408
29409
29410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29411   void * jresult ;
29412   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29413   Dali::Vector2 *result = 0 ;
29414
29415   arg1 = (Dali::TouchPoint *)jarg1;
29416   result = (Dali::Vector2 *)& ((arg1)->screen);
29417   jresult = (void *)result;
29418   return jresult;
29419 }
29420
29421
29422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29423   void * jresult ;
29424   Dali::TouchEvent *result = 0 ;
29425
29426   {
29427     try {
29428       result = (Dali::TouchEvent *)new Dali::TouchEvent();
29429     } catch (std::out_of_range& e) {
29430       {
29431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29432       };
29433     } catch (std::exception& e) {
29434       {
29435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29436       };
29437     } catch (Dali::DaliException e) {
29438       {
29439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29440       };
29441     } catch (...) {
29442       {
29443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29444       };
29445     }
29446   }
29447
29448   jresult = (void *)result;
29449   return jresult;
29450 }
29451
29452
29453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29454   void * jresult ;
29455   Dali::TouchEvent *arg1 = 0 ;
29456   Dali::TouchEvent *result = 0 ;
29457
29458   arg1 = (Dali::TouchEvent *)jarg1;
29459   if (!arg1) {
29460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
29461     return 0;
29462   }
29463   {
29464     try {
29465       result = (Dali::TouchEvent *)new Dali::TouchEvent((Dali::TouchEvent const &)*arg1);
29466     } catch (std::out_of_range& e) {
29467       {
29468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29469       };
29470     } catch (std::exception& e) {
29471       {
29472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29473       };
29474     } catch (Dali::DaliException e) {
29475       {
29476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29477       };
29478     } catch (...) {
29479       {
29480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29481       };
29482     }
29483   }
29484
29485   jresult = (void *)result;
29486   return jresult;
29487 }
29488
29489
29490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29491   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29492
29493   arg1 = (Dali::TouchEvent *)jarg1;
29494   {
29495     try {
29496       delete arg1;
29497     } catch (std::out_of_range& e) {
29498       {
29499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29500       };
29501     } catch (std::exception& e) {
29502       {
29503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29504       };
29505     } catch (Dali::DaliException e) {
29506       {
29507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29508       };
29509     } catch (...) {
29510       {
29511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29512       };
29513     }
29514   }
29515
29516 }
29517
29518
29519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29520   void * jresult ;
29521   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29522   Dali::TouchEvent *arg2 = 0 ;
29523   Dali::TouchEvent *result = 0 ;
29524
29525   arg1 = (Dali::TouchEvent *)jarg1;
29526   arg2 = (Dali::TouchEvent *)jarg2;
29527   if (!arg2) {
29528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
29529     return 0;
29530   }
29531   {
29532     try {
29533       result = (Dali::TouchEvent *) &(arg1)->operator =((Dali::TouchEvent const &)*arg2);
29534     } catch (std::out_of_range& e) {
29535       {
29536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29537       };
29538     } catch (std::exception& e) {
29539       {
29540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29541       };
29542     } catch (Dali::DaliException e) {
29543       {
29544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29545       };
29546     } catch (...) {
29547       {
29548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29549       };
29550     }
29551   }
29552
29553   jresult = (void *)result;
29554   return jresult;
29555 }
29556
29557
29558 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29559   unsigned long jresult ;
29560   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29561   unsigned long result;
29562
29563   arg1 = (Dali::TouchEvent *)jarg1;
29564   {
29565     try {
29566       result = (unsigned long)((Dali::TouchEvent const *)arg1)->GetTime();
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 = (unsigned long)result;
29587   return jresult;
29588 }
29589
29590
29591 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29592   unsigned long jresult ;
29593   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29594   std::size_t result;
29595
29596   arg1 = (Dali::TouchEvent *)jarg1;
29597   {
29598     try {
29599       result = ((Dali::TouchEvent const *)arg1)->GetPointCount();
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 int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29625   int jresult ;
29626   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29627   std::size_t arg2 ;
29628   int32_t result;
29629
29630   arg1 = (Dali::TouchEvent *)jarg1;
29631   arg2 = (std::size_t)jarg2;
29632   {
29633     try {
29634       result = ((Dali::TouchEvent const *)arg1)->GetDeviceId(arg2);
29635     } catch (std::out_of_range& e) {
29636       {
29637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29638       };
29639     } catch (std::exception& e) {
29640       {
29641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29642       };
29643     } catch (Dali::DaliException e) {
29644       {
29645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29646       };
29647     } catch (...) {
29648       {
29649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29650       };
29651     }
29652   }
29653
29654   jresult = result;
29655   return jresult;
29656 }
29657
29658
29659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29660   int jresult ;
29661   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29662   std::size_t arg2 ;
29663   Dali::PointState::Type result;
29664
29665   arg1 = (Dali::TouchEvent *)jarg1;
29666   arg2 = (std::size_t)jarg2;
29667   {
29668     try {
29669       result = (Dali::PointState::Type)((Dali::TouchEvent const *)arg1)->GetState(arg2);
29670     } catch (std::out_of_range& e) {
29671       {
29672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29673       };
29674     } catch (std::exception& e) {
29675       {
29676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29677       };
29678     } catch (Dali::DaliException e) {
29679       {
29680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29681       };
29682     } catch (...) {
29683       {
29684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29685       };
29686     }
29687   }
29688
29689   jresult = (int)result;
29690   return jresult;
29691 }
29692
29693
29694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29695   void * jresult ;
29696   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29697   std::size_t arg2 ;
29698   Dali::Actor result;
29699
29700   arg1 = (Dali::TouchEvent *)jarg1;
29701   arg2 = (std::size_t)jarg2;
29702   {
29703     try {
29704       result = ((Dali::TouchEvent const *)arg1)->GetHitActor(arg2);
29705     } catch (std::out_of_range& e) {
29706       {
29707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29708       };
29709     } catch (std::exception& e) {
29710       {
29711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29712       };
29713     } catch (Dali::DaliException e) {
29714       {
29715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29716       };
29717     } catch (...) {
29718       {
29719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29720       };
29721     }
29722   }
29723
29724   jresult = new Dali::Actor((const Dali::Actor &)result);
29725   return jresult;
29726 }
29727
29728
29729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29730   void * jresult ;
29731   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29732   std::size_t arg2 ;
29733   Dali::Vector2 *result = 0 ;
29734
29735   arg1 = (Dali::TouchEvent *)jarg1;
29736   arg2 = (std::size_t)jarg2;
29737   {
29738     try {
29739       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetLocalPosition(arg2);
29740     } catch (std::out_of_range& e) {
29741       {
29742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29743       };
29744     } catch (std::exception& e) {
29745       {
29746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29747       };
29748     } catch (Dali::DaliException e) {
29749       {
29750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29751       };
29752     } catch (...) {
29753       {
29754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29755       };
29756     }
29757   }
29758
29759   jresult = (void *)result;
29760   return jresult;
29761 }
29762
29763
29764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
29765   void * jresult ;
29766   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29767   std::size_t arg2 ;
29768   Dali::Vector2 *result = 0 ;
29769
29770   arg1 = (Dali::TouchEvent *)jarg1;
29771   arg2 = (std::size_t)jarg2;
29772   {
29773     try {
29774       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetScreenPosition(arg2);
29775     } catch (std::out_of_range& e) {
29776       {
29777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29778       };
29779     } catch (std::exception& e) {
29780       {
29781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29782       };
29783     } catch (Dali::DaliException e) {
29784       {
29785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29786       };
29787     } catch (...) {
29788       {
29789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29790       };
29791     }
29792   }
29793
29794   jresult = (void *)result;
29795   return jresult;
29796 }
29797
29798
29799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
29800   float jresult ;
29801   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29802   std::size_t arg2 ;
29803   float result;
29804
29805   arg1 = (Dali::TouchEvent *)jarg1;
29806   arg2 = (std::size_t)jarg2;
29807   {
29808     try {
29809       result = (float)((Dali::TouchEvent const *)arg1)->GetRadius(arg2);
29810     } catch (std::out_of_range& e) {
29811       {
29812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29813       };
29814     } catch (std::exception& e) {
29815       {
29816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29817       };
29818     } catch (Dali::DaliException e) {
29819       {
29820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29821       };
29822     } catch (...) {
29823       {
29824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29825       };
29826     }
29827   }
29828
29829   jresult = result;
29830   return jresult;
29831 }
29832
29833
29834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
29835   void * jresult ;
29836   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29837   std::size_t arg2 ;
29838   Dali::Vector2 *result = 0 ;
29839
29840   arg1 = (Dali::TouchEvent *)jarg1;
29841   arg2 = (std::size_t)jarg2;
29842   {
29843     try {
29844       result = (Dali::Vector2 *) &((Dali::TouchEvent const *)arg1)->GetEllipseRadius(arg2);
29845     } catch (std::out_of_range& e) {
29846       {
29847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29848       };
29849     } catch (std::exception& e) {
29850       {
29851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29852       };
29853     } catch (Dali::DaliException e) {
29854       {
29855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29856       };
29857     } catch (...) {
29858       {
29859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29860       };
29861     }
29862   }
29863
29864   jresult = (void *)result;
29865   return jresult;
29866 }
29867
29868
29869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
29870   float jresult ;
29871   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29872   std::size_t arg2 ;
29873   float result;
29874
29875   arg1 = (Dali::TouchEvent *)jarg1;
29876   arg2 = (std::size_t)jarg2;
29877   {
29878     try {
29879       result = (float)((Dali::TouchEvent const *)arg1)->GetPressure(arg2);
29880     } catch (std::out_of_range& e) {
29881       {
29882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29883       };
29884     } catch (std::exception& e) {
29885       {
29886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29887       };
29888     } catch (Dali::DaliException e) {
29889       {
29890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29891       };
29892     } catch (...) {
29893       {
29894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29895       };
29896     }
29897   }
29898
29899   jresult = result;
29900   return jresult;
29901 }
29902
29903
29904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
29905   void * jresult ;
29906   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29907   std::size_t arg2 ;
29908   Dali::Degree result;
29909
29910   arg1 = (Dali::TouchEvent *)jarg1;
29911   arg2 = (std::size_t)jarg2;
29912   {
29913     try {
29914       result = ((Dali::TouchEvent const *)arg1)->GetAngle(arg2);
29915     } catch (std::out_of_range& e) {
29916       {
29917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29918       };
29919     } catch (std::exception& e) {
29920       {
29921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29922       };
29923     } catch (Dali::DaliException e) {
29924       {
29925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29926       };
29927     } catch (...) {
29928       {
29929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29930       };
29931     }
29932   }
29933
29934   jresult = new Dali::Degree((const Dali::Degree &)result);
29935   return jresult;
29936 }
29937
29938
29939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
29940   int jresult ;
29941   Dali::TouchEvent *arg1 = (Dali::TouchEvent *) 0 ;
29942   std::size_t arg2 ;
29943   Dali::MouseButton::Type result;
29944
29945   arg1 = (Dali::TouchEvent *)jarg1;
29946   arg2 = (std::size_t)jarg2;
29947   {
29948     try {
29949       result = ((Dali::TouchEvent const *)arg1)->GetMouseButton(arg2);
29950     } catch (std::out_of_range& e) {
29951       {
29952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29953       };
29954     } catch (std::exception& e) {
29955       {
29956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29957       };
29958     } catch (Dali::DaliException e) {
29959       {
29960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29961       };
29962     } catch (...) {
29963       {
29964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29965       };
29966     }
29967   }
29968
29969   jresult = static_cast< int >(result);
29970   return jresult;
29971 }
29972
29973
29974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
29975   void * jresult ;
29976   Dali::GestureDetector *result = 0 ;
29977
29978   {
29979     try {
29980       result = (Dali::GestureDetector *)new Dali::GestureDetector();
29981     } catch (std::out_of_range& e) {
29982       {
29983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29984       };
29985     } catch (std::exception& e) {
29986       {
29987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29988       };
29989     } catch (Dali::DaliException e) {
29990       {
29991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29992       };
29993     } catch (...) {
29994       {
29995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29996       };
29997     }
29998   }
29999
30000   jresult = (void *)result;
30001   return jresult;
30002 }
30003
30004
30005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30006   void * jresult ;
30007   Dali::BaseHandle arg1 ;
30008   Dali::BaseHandle *argp1 ;
30009   Dali::GestureDetector result;
30010
30011   argp1 = (Dali::BaseHandle *)jarg1;
30012   if (!argp1) {
30013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30014     return 0;
30015   }
30016   arg1 = *argp1;
30017   {
30018     try {
30019       result = Dali::GestureDetector::DownCast(arg1);
30020     } catch (std::out_of_range& e) {
30021       {
30022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30023       };
30024     } catch (std::exception& e) {
30025       {
30026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30027       };
30028     } catch (Dali::DaliException e) {
30029       {
30030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30031       };
30032     } catch (...) {
30033       {
30034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30035       };
30036     }
30037   }
30038
30039   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30040   return jresult;
30041 }
30042
30043
30044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30045   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30046
30047   arg1 = (Dali::GestureDetector *)jarg1;
30048   {
30049     try {
30050       delete arg1;
30051     } catch (std::out_of_range& e) {
30052       {
30053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30054       };
30055     } catch (std::exception& e) {
30056       {
30057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30058       };
30059     } catch (Dali::DaliException e) {
30060       {
30061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30062       };
30063     } catch (...) {
30064       {
30065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30066       };
30067     }
30068   }
30069
30070 }
30071
30072
30073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30074   void * jresult ;
30075   Dali::GestureDetector *arg1 = 0 ;
30076   Dali::GestureDetector *result = 0 ;
30077
30078   arg1 = (Dali::GestureDetector *)jarg1;
30079   if (!arg1) {
30080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30081     return 0;
30082   }
30083   {
30084     try {
30085       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30086     } catch (std::out_of_range& e) {
30087       {
30088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30089       };
30090     } catch (std::exception& e) {
30091       {
30092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30093       };
30094     } catch (Dali::DaliException e) {
30095       {
30096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30097       };
30098     } catch (...) {
30099       {
30100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30101       };
30102     }
30103   }
30104
30105   jresult = (void *)result;
30106   return jresult;
30107 }
30108
30109
30110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30111   void * jresult ;
30112   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30113   Dali::GestureDetector *arg2 = 0 ;
30114   Dali::GestureDetector *result = 0 ;
30115
30116   arg1 = (Dali::GestureDetector *)jarg1;
30117   arg2 = (Dali::GestureDetector *)jarg2;
30118   if (!arg2) {
30119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30120     return 0;
30121   }
30122   {
30123     try {
30124       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30125     } catch (std::out_of_range& e) {
30126       {
30127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30128       };
30129     } catch (std::exception& e) {
30130       {
30131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30132       };
30133     } catch (Dali::DaliException e) {
30134       {
30135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30136       };
30137     } catch (...) {
30138       {
30139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30140       };
30141     }
30142   }
30143
30144   jresult = (void *)result;
30145   return jresult;
30146 }
30147
30148
30149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30150   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30151   Dali::Actor arg2 ;
30152   Dali::Actor *argp2 ;
30153
30154   arg1 = (Dali::GestureDetector *)jarg1;
30155   argp2 = (Dali::Actor *)jarg2;
30156   if (!argp2) {
30157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30158     return ;
30159   }
30160   arg2 = *argp2;
30161   {
30162     try {
30163       (arg1)->Attach(arg2);
30164     } catch (std::out_of_range& e) {
30165       {
30166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30167       };
30168     } catch (std::exception& e) {
30169       {
30170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30171       };
30172     } catch (Dali::DaliException e) {
30173       {
30174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30175       };
30176     } catch (...) {
30177       {
30178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30179       };
30180     }
30181   }
30182
30183 }
30184
30185
30186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30187   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30188   Dali::Actor arg2 ;
30189   Dali::Actor *argp2 ;
30190
30191   arg1 = (Dali::GestureDetector *)jarg1;
30192   argp2 = (Dali::Actor *)jarg2;
30193   if (!argp2) {
30194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30195     return ;
30196   }
30197   arg2 = *argp2;
30198   {
30199     try {
30200       (arg1)->Detach(arg2);
30201     } catch (std::out_of_range& e) {
30202       {
30203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30204       };
30205     } catch (std::exception& e) {
30206       {
30207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30208       };
30209     } catch (Dali::DaliException e) {
30210       {
30211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30212       };
30213     } catch (...) {
30214       {
30215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30216       };
30217     }
30218   }
30219
30220 }
30221
30222
30223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30224   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30225
30226   arg1 = (Dali::GestureDetector *)jarg1;
30227   {
30228     try {
30229       (arg1)->DetachAll();
30230     } catch (std::out_of_range& e) {
30231       {
30232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30233       };
30234     } catch (std::exception& e) {
30235       {
30236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30237       };
30238     } catch (Dali::DaliException e) {
30239       {
30240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30241       };
30242     } catch (...) {
30243       {
30244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30245       };
30246     }
30247   }
30248
30249 }
30250
30251
30252 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30253   unsigned long jresult ;
30254   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30255   size_t result;
30256
30257   arg1 = (Dali::GestureDetector *)jarg1;
30258   {
30259     try {
30260       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30261     } catch (std::out_of_range& e) {
30262       {
30263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30264       };
30265     } catch (std::exception& e) {
30266       {
30267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30268       };
30269     } catch (Dali::DaliException e) {
30270       {
30271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30272       };
30273     } catch (...) {
30274       {
30275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30276       };
30277     }
30278   }
30279
30280   jresult = (unsigned long)result;
30281   return jresult;
30282 }
30283
30284
30285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30286   void * jresult ;
30287   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30288   size_t arg2 ;
30289   Dali::Actor result;
30290
30291   arg1 = (Dali::GestureDetector *)jarg1;
30292   arg2 = (size_t)jarg2;
30293   {
30294     try {
30295       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30296     } catch (std::out_of_range& e) {
30297       {
30298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30299       };
30300     } catch (std::exception& e) {
30301       {
30302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30303       };
30304     } catch (Dali::DaliException e) {
30305       {
30306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30307       };
30308     } catch (...) {
30309       {
30310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30311       };
30312     }
30313   }
30314
30315   jresult = new Dali::Actor((const Dali::Actor &)result);
30316   return jresult;
30317 }
30318
30319
30320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30321   void * jresult ;
30322   Dali::Gesture *arg1 = 0 ;
30323   Dali::Gesture *result = 0 ;
30324
30325   arg1 = (Dali::Gesture *)jarg1;
30326   if (!arg1) {
30327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30328     return 0;
30329   }
30330   {
30331     try {
30332       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30333     } catch (std::out_of_range& e) {
30334       {
30335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30336       };
30337     } catch (std::exception& e) {
30338       {
30339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30340       };
30341     } catch (Dali::DaliException e) {
30342       {
30343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30344       };
30345     } catch (...) {
30346       {
30347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30348       };
30349     }
30350   }
30351
30352   jresult = (void *)result;
30353   return jresult;
30354 }
30355
30356
30357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30358   void * jresult ;
30359   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30360   Dali::Gesture *arg2 = 0 ;
30361   Dali::Gesture *result = 0 ;
30362
30363   arg1 = (Dali::Gesture *)jarg1;
30364   arg2 = (Dali::Gesture *)jarg2;
30365   if (!arg2) {
30366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30367     return 0;
30368   }
30369   {
30370     try {
30371       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30372     } catch (std::out_of_range& e) {
30373       {
30374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30375       };
30376     } catch (std::exception& e) {
30377       {
30378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30379       };
30380     } catch (Dali::DaliException e) {
30381       {
30382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30383       };
30384     } catch (...) {
30385       {
30386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30387       };
30388     }
30389   }
30390
30391   jresult = (void *)result;
30392   return jresult;
30393 }
30394
30395
30396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30397   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30398
30399   arg1 = (Dali::Gesture *)jarg1;
30400   {
30401     try {
30402       delete arg1;
30403     } catch (std::out_of_range& e) {
30404       {
30405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30406       };
30407     } catch (std::exception& e) {
30408       {
30409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30410       };
30411     } catch (Dali::DaliException e) {
30412       {
30413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30414       };
30415     } catch (...) {
30416       {
30417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30418       };
30419     }
30420   }
30421
30422 }
30423
30424
30425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30426   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30427   Dali::Gesture::Type arg2 ;
30428
30429   arg1 = (Dali::Gesture *)jarg1;
30430   arg2 = (Dali::Gesture::Type)jarg2;
30431   if (arg1) (arg1)->type = arg2;
30432 }
30433
30434
30435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30436   int jresult ;
30437   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30438   Dali::Gesture::Type result;
30439
30440   arg1 = (Dali::Gesture *)jarg1;
30441   result = (Dali::Gesture::Type) ((arg1)->type);
30442   jresult = (int)result;
30443   return jresult;
30444 }
30445
30446
30447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30448   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30449   Dali::Gesture::State arg2 ;
30450
30451   arg1 = (Dali::Gesture *)jarg1;
30452   arg2 = (Dali::Gesture::State)jarg2;
30453   if (arg1) (arg1)->state = arg2;
30454 }
30455
30456
30457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30458   int jresult ;
30459   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30460   Dali::Gesture::State result;
30461
30462   arg1 = (Dali::Gesture *)jarg1;
30463   result = (Dali::Gesture::State) ((arg1)->state);
30464   jresult = (int)result;
30465   return jresult;
30466 }
30467
30468
30469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30470   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30471   unsigned int arg2 ;
30472
30473   arg1 = (Dali::Gesture *)jarg1;
30474   arg2 = (unsigned int)jarg2;
30475   if (arg1) (arg1)->time = arg2;
30476 }
30477
30478
30479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30480   unsigned int jresult ;
30481   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30482   unsigned int result;
30483
30484   arg1 = (Dali::Gesture *)jarg1;
30485   result = (unsigned int) ((arg1)->time);
30486   jresult = result;
30487   return jresult;
30488 }
30489
30490
30491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30492   void * jresult ;
30493   Dali::HoverEvent *result = 0 ;
30494
30495   {
30496     try {
30497       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30498     } catch (std::out_of_range& e) {
30499       {
30500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30501       };
30502     } catch (std::exception& e) {
30503       {
30504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30505       };
30506     } catch (Dali::DaliException e) {
30507       {
30508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30509       };
30510     } catch (...) {
30511       {
30512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30513       };
30514     }
30515   }
30516
30517   jresult = (void *)result;
30518   return jresult;
30519 }
30520
30521
30522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30523   void * jresult ;
30524   unsigned long arg1 ;
30525   Dali::HoverEvent *result = 0 ;
30526
30527   arg1 = (unsigned long)jarg1;
30528   {
30529     try {
30530       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
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_delete_Hover(void * jarg1) {
30556   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30557
30558   arg1 = (Dali::HoverEvent *)jarg1;
30559   {
30560     try {
30561       delete arg1;
30562     } catch (std::out_of_range& e) {
30563       {
30564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30565       };
30566     } catch (std::exception& e) {
30567       {
30568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30569       };
30570     } catch (Dali::DaliException e) {
30571       {
30572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30573       };
30574     } catch (...) {
30575       {
30576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30577       };
30578     }
30579   }
30580
30581 }
30582
30583
30584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30585   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30586   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30587
30588   arg1 = (Dali::HoverEvent *)jarg1;
30589   arg2 = (Dali::TouchPointContainer *)jarg2;
30590   if (arg1) (arg1)->points = *arg2;
30591 }
30592
30593
30594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30595   void * jresult ;
30596   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30597   Dali::TouchPointContainer *result = 0 ;
30598
30599   arg1 = (Dali::HoverEvent *)jarg1;
30600   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30601   jresult = (void *)result;
30602   return jresult;
30603 }
30604
30605
30606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30607   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30608   unsigned long arg2 ;
30609
30610   arg1 = (Dali::HoverEvent *)jarg1;
30611   arg2 = (unsigned long)jarg2;
30612   if (arg1) (arg1)->time = arg2;
30613 }
30614
30615
30616 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30617   unsigned long jresult ;
30618   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30619   unsigned long result;
30620
30621   arg1 = (Dali::HoverEvent *)jarg1;
30622   result = (unsigned long) ((arg1)->time);
30623   jresult = (unsigned long)result;
30624   return jresult;
30625 }
30626
30627
30628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30629   unsigned int jresult ;
30630   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30631   unsigned int result;
30632
30633   arg1 = (Dali::HoverEvent *)jarg1;
30634   {
30635     try {
30636       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30637     } catch (std::out_of_range& e) {
30638       {
30639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30640       };
30641     } catch (std::exception& e) {
30642       {
30643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30644       };
30645     } catch (Dali::DaliException e) {
30646       {
30647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30648       };
30649     } catch (...) {
30650       {
30651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30652       };
30653     }
30654   }
30655
30656   jresult = result;
30657   return jresult;
30658 }
30659
30660
30661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30662   void * jresult ;
30663   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30664   unsigned int arg2 ;
30665   Dali::TouchPoint *result = 0 ;
30666
30667   arg1 = (Dali::HoverEvent *)jarg1;
30668   arg2 = (unsigned int)jarg2;
30669   {
30670     try {
30671       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30672     } catch (std::out_of_range& e) {
30673       {
30674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30675       };
30676     } catch (std::exception& e) {
30677       {
30678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30679       };
30680     } catch (Dali::DaliException e) {
30681       {
30682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30683       };
30684     } catch (...) {
30685       {
30686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30687       };
30688     }
30689   }
30690
30691   jresult = (void *)result;
30692   return jresult;
30693 }
30694
30695
30696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30697   void * jresult ;
30698   Dali::KeyEvent *result = 0 ;
30699
30700   {
30701     try {
30702       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30703     } catch (std::out_of_range& e) {
30704       {
30705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30706       };
30707     } catch (std::exception& e) {
30708       {
30709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30710       };
30711     } catch (Dali::DaliException e) {
30712       {
30713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30714       };
30715     } catch (...) {
30716       {
30717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30718       };
30719     }
30720   }
30721
30722   jresult = (void *)result;
30723   return jresult;
30724 }
30725
30726
30727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30728   void * jresult ;
30729   std::string *arg1 = 0 ;
30730   std::string *arg2 = 0 ;
30731   int arg3 ;
30732   int arg4 ;
30733   unsigned long arg5 ;
30734   Dali::KeyEvent::State *arg6 = 0 ;
30735   Dali::KeyEvent::State temp6 ;
30736   Dali::KeyEvent *result = 0 ;
30737
30738   if (!jarg1) {
30739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30740     return 0;
30741   }
30742   std::string arg1_str(jarg1);
30743   arg1 = &arg1_str;
30744   if (!jarg2) {
30745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30746     return 0;
30747   }
30748   std::string arg2_str(jarg2);
30749   arg2 = &arg2_str;
30750   arg3 = (int)jarg3;
30751   arg4 = (int)jarg4;
30752   arg5 = (unsigned long)jarg5;
30753   temp6 = (Dali::KeyEvent::State)jarg6;
30754   arg6 = &temp6;
30755   {
30756     try {
30757       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
30758     } catch (std::out_of_range& e) {
30759       {
30760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30761       };
30762     } catch (std::exception& e) {
30763       {
30764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30765       };
30766     } catch (Dali::DaliException e) {
30767       {
30768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30769       };
30770     } catch (...) {
30771       {
30772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30773       };
30774     }
30775   }
30776
30777   jresult = (void *)result;
30778
30779   //argout typemap for const std::string&
30780
30781
30782   //argout typemap for const std::string&
30783
30784   return jresult;
30785 }
30786
30787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
30788   void * jresult ;
30789   Dali::KeyEvent *arg1 = 0 ;
30790   Dali::KeyEvent *result = 0 ;
30791
30792   arg1 = (Dali::KeyEvent *)jarg1;
30793   if (!arg1) {
30794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30795     return 0;
30796   }
30797   {
30798     try {
30799       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
30800     } catch (std::out_of_range& e) {
30801       {
30802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30803       };
30804     } catch (std::exception& e) {
30805       {
30806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30807       };
30808     } catch (Dali::DaliException e) {
30809       {
30810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30811       };
30812     } catch (...) {
30813       {
30814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30815       };
30816     }
30817   }
30818
30819   jresult = (void *)result;
30820   return jresult;
30821 }
30822
30823
30824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
30825   void * jresult ;
30826   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30827   Dali::KeyEvent *arg2 = 0 ;
30828   Dali::KeyEvent *result = 0 ;
30829
30830   arg1 = (Dali::KeyEvent *)jarg1;
30831   arg2 = (Dali::KeyEvent *)jarg2;
30832   if (!arg2) {
30833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30834     return 0;
30835   }
30836   {
30837     try {
30838       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
30839     } catch (std::out_of_range& e) {
30840       {
30841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30842       };
30843     } catch (std::exception& e) {
30844       {
30845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30846       };
30847     } catch (Dali::DaliException e) {
30848       {
30849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30850       };
30851     } catch (...) {
30852       {
30853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30854       };
30855     }
30856   }
30857
30858   jresult = (void *)result;
30859   return jresult;
30860 }
30861
30862
30863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
30864   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30865
30866   arg1 = (Dali::KeyEvent *)jarg1;
30867   {
30868     try {
30869       delete arg1;
30870     } catch (std::out_of_range& e) {
30871       {
30872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30873       };
30874     } catch (std::exception& e) {
30875       {
30876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30877       };
30878     } catch (Dali::DaliException e) {
30879       {
30880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30881       };
30882     } catch (...) {
30883       {
30884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30885       };
30886     }
30887   }
30888
30889 }
30890
30891
30892 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
30893   unsigned int jresult ;
30894   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30895   bool result;
30896
30897   arg1 = (Dali::KeyEvent *)jarg1;
30898   {
30899     try {
30900       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
30901     } catch (std::out_of_range& e) {
30902       {
30903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30904       };
30905     } catch (std::exception& e) {
30906       {
30907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30908       };
30909     } catch (Dali::DaliException e) {
30910       {
30911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30912       };
30913     } catch (...) {
30914       {
30915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30916       };
30917     }
30918   }
30919
30920   jresult = result;
30921   return jresult;
30922 }
30923
30924
30925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
30926   unsigned int jresult ;
30927   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30928   bool result;
30929
30930   arg1 = (Dali::KeyEvent *)jarg1;
30931   {
30932     try {
30933       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
30934     } catch (std::out_of_range& e) {
30935       {
30936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30937       };
30938     } catch (std::exception& e) {
30939       {
30940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30941       };
30942     } catch (Dali::DaliException e) {
30943       {
30944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30945       };
30946     } catch (...) {
30947       {
30948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30949       };
30950     }
30951   }
30952
30953   jresult = result;
30954   return jresult;
30955 }
30956
30957
30958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
30959   unsigned int jresult ;
30960   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30961   bool result;
30962
30963   arg1 = (Dali::KeyEvent *)jarg1;
30964   {
30965     try {
30966       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
30967     } catch (std::out_of_range& e) {
30968       {
30969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30970       };
30971     } catch (std::exception& e) {
30972       {
30973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30974       };
30975     } catch (Dali::DaliException e) {
30976       {
30977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30978       };
30979     } catch (...) {
30980       {
30981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30982       };
30983     }
30984   }
30985
30986   jresult = result;
30987   return jresult;
30988 }
30989
30990
30991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
30992   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30993   std::string *arg2 = 0 ;
30994
30995   arg1 = (Dali::KeyEvent *)jarg1;
30996   if (!jarg2) {
30997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30998     return ;
30999   }
31000   std::string arg2_str(jarg2);
31001   arg2 = &arg2_str;
31002   if (arg1) (arg1)->keyPressedName = *arg2;
31003
31004   //argout typemap for const std::string&
31005
31006 }
31007
31008
31009 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31010   char * jresult ;
31011
31012   if( jarg1 == NULL )
31013   {
31014     jresult = SWIG_csharp_string_callback( "" );
31015   }
31016   else
31017   {
31018     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31019     std::string *result = 0;
31020
31021     arg1 = ( Dali::KeyEvent * )jarg1;
31022     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31023     jresult = SWIG_csharp_string_callback( result->c_str() );
31024   }
31025
31026   return jresult;
31027 }
31028
31029
31030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31031   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31032   std::string *arg2 = 0 ;
31033
31034   arg1 = (Dali::KeyEvent *)jarg1;
31035   if (!jarg2) {
31036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31037     return ;
31038   }
31039   std::string arg2_str(jarg2);
31040   arg2 = &arg2_str;
31041   if (arg1) (arg1)->keyPressed = *arg2;
31042
31043   //argout typemap for const std::string&
31044
31045 }
31046
31047
31048 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31049   char * jresult ;
31050   if( NULL == jarg1 )
31051   {
31052     jresult = SWIG_csharp_string_callback( "" );
31053   }
31054   else
31055   {
31056     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31057     std::string *result = 0;
31058
31059     arg1 = ( Dali::KeyEvent * )jarg1;
31060     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31061     jresult = SWIG_csharp_string_callback( result->c_str() );
31062   }
31063   return jresult;
31064 }
31065
31066
31067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31068   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31069   int arg2 ;
31070
31071   arg1 = (Dali::KeyEvent *)jarg1;
31072   arg2 = (int)jarg2;
31073   if (arg1) (arg1)->keyCode = arg2;
31074 }
31075
31076
31077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31078   int jresult ;
31079   if( NULL == jarg1 )
31080   {
31081     jresult = -1;
31082   }
31083   else
31084   {
31085     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31086     int result;
31087
31088     arg1 = ( Dali::KeyEvent * )jarg1;
31089     result = (int)( ( arg1 )->keyCode );
31090     jresult = result;
31091   }
31092   return jresult;
31093 }
31094
31095
31096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31097   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31098   int arg2 ;
31099
31100   arg1 = (Dali::KeyEvent *)jarg1;
31101   arg2 = (int)jarg2;
31102   if (arg1) (arg1)->keyModifier = arg2;
31103 }
31104
31105
31106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31107   int jresult ;
31108   if( jarg1 == NULL )
31109   {
31110     jresult = -1;
31111   }
31112   else
31113   {
31114     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31115     int result;
31116
31117     arg1 = ( Dali::KeyEvent * )jarg1;
31118     result = (int)( ( arg1 )->keyModifier );
31119     jresult = result;
31120   }
31121   return jresult;
31122 }
31123
31124
31125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31126   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31127   unsigned long arg2 ;
31128
31129   arg1 = (Dali::KeyEvent *)jarg1;
31130   arg2 = (unsigned long)jarg2;
31131   if (arg1) (arg1)->time = arg2;
31132 }
31133
31134
31135 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31136   unsigned long jresult ;
31137   if( jarg1 == NULL )
31138   {
31139     jresult = 0;
31140   }
31141   else
31142   {
31143     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31144     unsigned long result;
31145
31146     arg1 = ( Dali::KeyEvent * )jarg1;
31147     result = (unsigned long)( ( arg1 )->time );
31148     jresult = (unsigned long)result;
31149   }
31150   return jresult;
31151 }
31152
31153
31154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31155   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31156   Dali::KeyEvent::State arg2 ;
31157
31158   arg1 = (Dali::KeyEvent *)jarg1;
31159   arg2 = (Dali::KeyEvent::State)jarg2;
31160   if (arg1) (arg1)->state = arg2;
31161 }
31162
31163
31164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31165   int jresult ;
31166   if( jarg1 == NULL )
31167   {
31168     jresult = -1;
31169   }
31170   else
31171   {
31172     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31173     Dali::KeyEvent::State result;
31174
31175     arg1 = ( Dali::KeyEvent * )jarg1;
31176     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31177     jresult = (int)result;
31178   }
31179   return jresult;
31180 }
31181
31182 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31183   char * jresult ;
31184   std::string result;
31185   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31186
31187   arg1 = (Dali::KeyEvent *)jarg1;
31188   if (!arg1) {
31189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31190     return 0;
31191   }
31192   {
31193     try {
31194       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31195     } catch (std::out_of_range& e) {
31196       {
31197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31198       };
31199     } catch (std::exception& e) {
31200       {
31201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31202       };
31203     } catch (Dali::DaliException e) {
31204       {
31205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31206       };
31207     } catch (...) {
31208       {
31209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31210       };
31211     }
31212
31213   }
31214
31215   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31216   return jresult;
31217 }
31218
31219
31220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31221   void * jresult ;
31222   Dali::LongPressGestureDetector *result = 0 ;
31223
31224   {
31225     try {
31226       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31227     } catch (std::out_of_range& e) {
31228       {
31229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31230       };
31231     } catch (std::exception& e) {
31232       {
31233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31234       };
31235     } catch (Dali::DaliException e) {
31236       {
31237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31238       };
31239     } catch (...) {
31240       {
31241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31242       };
31243     }
31244   }
31245
31246   jresult = (void *)result;
31247   return jresult;
31248 }
31249
31250
31251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31252   void * jresult ;
31253   Dali::LongPressGestureDetector result;
31254
31255   {
31256     try {
31257       result = Dali::LongPressGestureDetector::New();
31258     } catch (std::out_of_range& e) {
31259       {
31260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31261       };
31262     } catch (std::exception& e) {
31263       {
31264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31265       };
31266     } catch (Dali::DaliException e) {
31267       {
31268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31269       };
31270     } catch (...) {
31271       {
31272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31273       };
31274     }
31275   }
31276
31277   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31278   return jresult;
31279 }
31280
31281
31282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31283   void * jresult ;
31284   unsigned int arg1 ;
31285   Dali::LongPressGestureDetector result;
31286
31287   arg1 = (unsigned int)jarg1;
31288   {
31289     try {
31290       result = Dali::LongPressGestureDetector::New(arg1);
31291     } catch (std::out_of_range& e) {
31292       {
31293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31294       };
31295     } catch (std::exception& e) {
31296       {
31297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31298       };
31299     } catch (Dali::DaliException e) {
31300       {
31301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31302       };
31303     } catch (...) {
31304       {
31305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31306       };
31307     }
31308   }
31309
31310   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31311   return jresult;
31312 }
31313
31314
31315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31316   void * jresult ;
31317   unsigned int arg1 ;
31318   unsigned int arg2 ;
31319   Dali::LongPressGestureDetector result;
31320
31321   arg1 = (unsigned int)jarg1;
31322   arg2 = (unsigned int)jarg2;
31323   {
31324     try {
31325       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31326     } catch (std::out_of_range& e) {
31327       {
31328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31329       };
31330     } catch (std::exception& e) {
31331       {
31332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31333       };
31334     } catch (Dali::DaliException e) {
31335       {
31336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31337       };
31338     } catch (...) {
31339       {
31340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31341       };
31342     }
31343   }
31344
31345   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31346   return jresult;
31347 }
31348
31349
31350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31351   void * jresult ;
31352   Dali::BaseHandle arg1 ;
31353   Dali::BaseHandle *argp1 ;
31354   Dali::LongPressGestureDetector result;
31355
31356   argp1 = (Dali::BaseHandle *)jarg1;
31357   if (!argp1) {
31358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31359     return 0;
31360   }
31361   arg1 = *argp1;
31362   {
31363     try {
31364       result = Dali::LongPressGestureDetector::DownCast(arg1);
31365     } catch (std::out_of_range& e) {
31366       {
31367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31368       };
31369     } catch (std::exception& e) {
31370       {
31371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31372       };
31373     } catch (Dali::DaliException e) {
31374       {
31375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31376       };
31377     } catch (...) {
31378       {
31379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31380       };
31381     }
31382   }
31383
31384   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31385   return jresult;
31386 }
31387
31388
31389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31390   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31391
31392   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31393   {
31394     try {
31395       delete arg1;
31396     } catch (std::out_of_range& e) {
31397       {
31398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31399       };
31400     } catch (std::exception& e) {
31401       {
31402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31403       };
31404     } catch (Dali::DaliException e) {
31405       {
31406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31407       };
31408     } catch (...) {
31409       {
31410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31411       };
31412     }
31413   }
31414
31415 }
31416
31417
31418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31419   void * jresult ;
31420   Dali::LongPressGestureDetector *arg1 = 0 ;
31421   Dali::LongPressGestureDetector *result = 0 ;
31422
31423   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31424   if (!arg1) {
31425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31426     return 0;
31427   }
31428   {
31429     try {
31430       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31431     } catch (std::out_of_range& e) {
31432       {
31433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31434       };
31435     } catch (std::exception& e) {
31436       {
31437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31438       };
31439     } catch (Dali::DaliException e) {
31440       {
31441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31442       };
31443     } catch (...) {
31444       {
31445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31446       };
31447     }
31448   }
31449
31450   jresult = (void *)result;
31451   return jresult;
31452 }
31453
31454
31455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31456   void * jresult ;
31457   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31458   Dali::LongPressGestureDetector *arg2 = 0 ;
31459   Dali::LongPressGestureDetector *result = 0 ;
31460
31461   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31462   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31463   if (!arg2) {
31464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31465     return 0;
31466   }
31467   {
31468     try {
31469       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31470     } catch (std::out_of_range& e) {
31471       {
31472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31473       };
31474     } catch (std::exception& e) {
31475       {
31476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31477       };
31478     } catch (Dali::DaliException e) {
31479       {
31480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31481       };
31482     } catch (...) {
31483       {
31484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31485       };
31486     }
31487   }
31488
31489   jresult = (void *)result;
31490   return jresult;
31491 }
31492
31493
31494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31495   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31496   unsigned int arg2 ;
31497
31498   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31499   arg2 = (unsigned int)jarg2;
31500   {
31501     try {
31502       (arg1)->SetTouchesRequired(arg2);
31503     } catch (std::out_of_range& e) {
31504       {
31505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31506       };
31507     } catch (std::exception& e) {
31508       {
31509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31510       };
31511     } catch (Dali::DaliException e) {
31512       {
31513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31514       };
31515     } catch (...) {
31516       {
31517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31518       };
31519     }
31520   }
31521
31522 }
31523
31524
31525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31526   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31527   unsigned int arg2 ;
31528   unsigned int arg3 ;
31529
31530   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31531   arg2 = (unsigned int)jarg2;
31532   arg3 = (unsigned int)jarg3;
31533   {
31534     try {
31535       (arg1)->SetTouchesRequired(arg2,arg3);
31536     } catch (std::out_of_range& e) {
31537       {
31538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31539       };
31540     } catch (std::exception& e) {
31541       {
31542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31543       };
31544     } catch (Dali::DaliException e) {
31545       {
31546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31547       };
31548     } catch (...) {
31549       {
31550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31551       };
31552     }
31553   }
31554
31555 }
31556
31557
31558 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31559   unsigned int jresult ;
31560   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31561   unsigned int result;
31562
31563   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31564   {
31565     try {
31566       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31567     } catch (std::out_of_range& e) {
31568       {
31569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31570       };
31571     } catch (std::exception& e) {
31572       {
31573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31574       };
31575     } catch (Dali::DaliException e) {
31576       {
31577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31578       };
31579     } catch (...) {
31580       {
31581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31582       };
31583     }
31584   }
31585
31586   jresult = result;
31587   return jresult;
31588 }
31589
31590
31591 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31592   unsigned int jresult ;
31593   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31594   unsigned int result;
31595
31596   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31597   {
31598     try {
31599       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31600     } catch (std::out_of_range& e) {
31601       {
31602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31603       };
31604     } catch (std::exception& e) {
31605       {
31606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31607       };
31608     } catch (Dali::DaliException e) {
31609       {
31610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31611       };
31612     } catch (...) {
31613       {
31614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31615       };
31616     }
31617   }
31618
31619   jresult = result;
31620   return jresult;
31621 }
31622
31623
31624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31625   void * jresult ;
31626   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31627   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31628
31629   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31630   {
31631     try {
31632       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31633     } catch (std::out_of_range& e) {
31634       {
31635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31636       };
31637     } catch (std::exception& e) {
31638       {
31639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31640       };
31641     } catch (Dali::DaliException e) {
31642       {
31643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31644       };
31645     } catch (...) {
31646       {
31647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31648       };
31649     }
31650   }
31651
31652   jresult = (void *)result;
31653   return jresult;
31654 }
31655
31656
31657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31658   void * jresult ;
31659   Dali::Gesture::State arg1 ;
31660   Dali::LongPressGesture *result = 0 ;
31661
31662   arg1 = (Dali::Gesture::State)jarg1;
31663   {
31664     try {
31665       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31666     } catch (std::out_of_range& e) {
31667       {
31668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31669       };
31670     } catch (std::exception& e) {
31671       {
31672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31673       };
31674     } catch (Dali::DaliException e) {
31675       {
31676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31677       };
31678     } catch (...) {
31679       {
31680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31681       };
31682     }
31683   }
31684
31685   jresult = (void *)result;
31686   return jresult;
31687 }
31688
31689
31690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31691   void * jresult ;
31692   Dali::LongPressGesture *arg1 = 0 ;
31693   Dali::LongPressGesture *result = 0 ;
31694
31695   arg1 = (Dali::LongPressGesture *)jarg1;
31696   if (!arg1) {
31697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31698     return 0;
31699   }
31700   {
31701     try {
31702       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31703     } catch (std::out_of_range& e) {
31704       {
31705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31706       };
31707     } catch (std::exception& e) {
31708       {
31709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31710       };
31711     } catch (Dali::DaliException e) {
31712       {
31713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31714       };
31715     } catch (...) {
31716       {
31717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31718       };
31719     }
31720   }
31721
31722   jresult = (void *)result;
31723   return jresult;
31724 }
31725
31726
31727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31728   void * jresult ;
31729   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31730   Dali::LongPressGesture *arg2 = 0 ;
31731   Dali::LongPressGesture *result = 0 ;
31732
31733   arg1 = (Dali::LongPressGesture *)jarg1;
31734   arg2 = (Dali::LongPressGesture *)jarg2;
31735   if (!arg2) {
31736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31737     return 0;
31738   }
31739   {
31740     try {
31741       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31742     } catch (std::out_of_range& e) {
31743       {
31744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31745       };
31746     } catch (std::exception& e) {
31747       {
31748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31749       };
31750     } catch (Dali::DaliException e) {
31751       {
31752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31753       };
31754     } catch (...) {
31755       {
31756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31757       };
31758     }
31759   }
31760
31761   jresult = (void *)result;
31762   return jresult;
31763 }
31764
31765
31766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
31767   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31768
31769   arg1 = (Dali::LongPressGesture *)jarg1;
31770   {
31771     try {
31772       delete arg1;
31773     } catch (std::out_of_range& e) {
31774       {
31775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31776       };
31777     } catch (std::exception& e) {
31778       {
31779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31780       };
31781     } catch (Dali::DaliException e) {
31782       {
31783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31784       };
31785     } catch (...) {
31786       {
31787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31788       };
31789     }
31790   }
31791
31792 }
31793
31794
31795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
31796   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31797   unsigned int arg2 ;
31798
31799   arg1 = (Dali::LongPressGesture *)jarg1;
31800   arg2 = (unsigned int)jarg2;
31801   if (arg1) (arg1)->numberOfTouches = arg2;
31802 }
31803
31804
31805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
31806   unsigned int jresult ;
31807   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31808   unsigned int result;
31809
31810   arg1 = (Dali::LongPressGesture *)jarg1;
31811   result = (unsigned int) ((arg1)->numberOfTouches);
31812   jresult = result;
31813   return jresult;
31814 }
31815
31816
31817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
31818   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31819   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31820
31821   arg1 = (Dali::LongPressGesture *)jarg1;
31822   arg2 = (Dali::Vector2 *)jarg2;
31823   if (arg1) (arg1)->screenPoint = *arg2;
31824 }
31825
31826
31827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
31828   void * jresult ;
31829   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31830   Dali::Vector2 *result = 0 ;
31831
31832   arg1 = (Dali::LongPressGesture *)jarg1;
31833   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
31834   jresult = (void *)result;
31835   return jresult;
31836 }
31837
31838
31839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
31840   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31841   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31842
31843   arg1 = (Dali::LongPressGesture *)jarg1;
31844   arg2 = (Dali::Vector2 *)jarg2;
31845   if (arg1) (arg1)->localPoint = *arg2;
31846 }
31847
31848
31849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
31850   void * jresult ;
31851   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31852   Dali::Vector2 *result = 0 ;
31853
31854   arg1 = (Dali::LongPressGesture *)jarg1;
31855   result = (Dali::Vector2 *)& ((arg1)->localPoint);
31856   jresult = (void *)result;
31857   return jresult;
31858 }
31859
31860
31861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
31862   void * jresult ;
31863   Dali::WheelEvent *result = 0 ;
31864
31865   {
31866     try {
31867       result = (Dali::WheelEvent *)new Dali::WheelEvent();
31868     } catch (std::out_of_range& e) {
31869       {
31870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31871       };
31872     } catch (std::exception& e) {
31873       {
31874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31875       };
31876     } catch (Dali::DaliException e) {
31877       {
31878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31879       };
31880     } catch (...) {
31881       {
31882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31883       };
31884     }
31885   }
31886
31887   jresult = (void *)result;
31888   return jresult;
31889 }
31890
31891
31892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
31893   void * jresult ;
31894   Dali::WheelEvent::Type arg1 ;
31895   int arg2 ;
31896   unsigned int arg3 ;
31897   Dali::Vector2 arg4 ;
31898   int arg5 ;
31899   unsigned int arg6 ;
31900   Dali::Vector2 *argp4 ;
31901   Dali::WheelEvent *result = 0 ;
31902
31903   arg1 = (Dali::WheelEvent::Type)jarg1;
31904   arg2 = (int)jarg2;
31905   arg3 = (unsigned int)jarg3;
31906   argp4 = (Dali::Vector2 *)jarg4;
31907   if (!argp4) {
31908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
31909     return 0;
31910   }
31911   arg4 = *argp4;
31912   arg5 = (int)jarg5;
31913   arg6 = (unsigned int)jarg6;
31914   {
31915     try {
31916       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
31917     } catch (std::out_of_range& e) {
31918       {
31919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31920       };
31921     } catch (std::exception& e) {
31922       {
31923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31924       };
31925     } catch (Dali::DaliException e) {
31926       {
31927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31928       };
31929     } catch (...) {
31930       {
31931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31932       };
31933     }
31934   }
31935
31936   jresult = (void *)result;
31937   return jresult;
31938 }
31939
31940
31941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
31942   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
31943
31944   arg1 = (Dali::WheelEvent *)jarg1;
31945   {
31946     try {
31947       delete arg1;
31948     } catch (std::out_of_range& e) {
31949       {
31950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31951       };
31952     } catch (std::exception& e) {
31953       {
31954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31955       };
31956     } catch (Dali::DaliException e) {
31957       {
31958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31959       };
31960     } catch (...) {
31961       {
31962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31963       };
31964     }
31965   }
31966
31967 }
31968
31969
31970 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
31971   unsigned int jresult ;
31972   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
31973   bool result;
31974
31975   arg1 = (Dali::WheelEvent *)jarg1;
31976   {
31977     try {
31978       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
31979     } catch (std::out_of_range& e) {
31980       {
31981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31982       };
31983     } catch (std::exception& e) {
31984       {
31985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31986       };
31987     } catch (Dali::DaliException e) {
31988       {
31989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31990       };
31991     } catch (...) {
31992       {
31993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31994       };
31995     }
31996   }
31997
31998   jresult = result;
31999   return jresult;
32000 }
32001
32002
32003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32004   unsigned int jresult ;
32005   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32006   bool result;
32007
32008   arg1 = (Dali::WheelEvent *)jarg1;
32009   {
32010     try {
32011       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32012     } catch (std::out_of_range& e) {
32013       {
32014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32015       };
32016     } catch (std::exception& e) {
32017       {
32018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32019       };
32020     } catch (Dali::DaliException e) {
32021       {
32022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32023       };
32024     } catch (...) {
32025       {
32026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32027       };
32028     }
32029   }
32030
32031   jresult = result;
32032   return jresult;
32033 }
32034
32035
32036 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32037   unsigned int jresult ;
32038   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32039   bool result;
32040
32041   arg1 = (Dali::WheelEvent *)jarg1;
32042   {
32043     try {
32044       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32045     } catch (std::out_of_range& e) {
32046       {
32047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32048       };
32049     } catch (std::exception& e) {
32050       {
32051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32052       };
32053     } catch (Dali::DaliException e) {
32054       {
32055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32056       };
32057     } catch (...) {
32058       {
32059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32060       };
32061     }
32062   }
32063
32064   jresult = result;
32065   return jresult;
32066 }
32067
32068
32069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32070   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32071   Dali::WheelEvent::Type arg2 ;
32072
32073   arg1 = (Dali::WheelEvent *)jarg1;
32074   arg2 = (Dali::WheelEvent::Type)jarg2;
32075   if (arg1) (arg1)->type = arg2;
32076 }
32077
32078
32079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32080   int jresult ;
32081   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32082   Dali::WheelEvent::Type result;
32083
32084   arg1 = (Dali::WheelEvent *)jarg1;
32085   result = (Dali::WheelEvent::Type) ((arg1)->type);
32086   jresult = (int)result;
32087   return jresult;
32088 }
32089
32090
32091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32092   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32093   int arg2 ;
32094
32095   arg1 = (Dali::WheelEvent *)jarg1;
32096   arg2 = (int)jarg2;
32097   if (arg1) (arg1)->direction = arg2;
32098 }
32099
32100
32101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32102   int jresult ;
32103   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32104   int result;
32105
32106   arg1 = (Dali::WheelEvent *)jarg1;
32107   result = (int) ((arg1)->direction);
32108   jresult = result;
32109   return jresult;
32110 }
32111
32112
32113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32114   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32115   unsigned int arg2 ;
32116
32117   arg1 = (Dali::WheelEvent *)jarg1;
32118   arg2 = (unsigned int)jarg2;
32119   if (arg1) (arg1)->modifiers = arg2;
32120 }
32121
32122
32123 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32124   unsigned int jresult ;
32125   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32126   unsigned int result;
32127
32128   arg1 = (Dali::WheelEvent *)jarg1;
32129   result = (unsigned int) ((arg1)->modifiers);
32130   jresult = result;
32131   return jresult;
32132 }
32133
32134
32135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32136   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32137   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32138
32139   arg1 = (Dali::WheelEvent *)jarg1;
32140   arg2 = (Dali::Vector2 *)jarg2;
32141   if (arg1) (arg1)->point = *arg2;
32142 }
32143
32144
32145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32146   void * jresult ;
32147   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32148   Dali::Vector2 *result = 0 ;
32149
32150   arg1 = (Dali::WheelEvent *)jarg1;
32151   result = (Dali::Vector2 *)& ((arg1)->point);
32152   jresult = (void *)result;
32153   return jresult;
32154 }
32155
32156
32157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32158   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32159   int arg2 ;
32160
32161   arg1 = (Dali::WheelEvent *)jarg1;
32162   arg2 = (int)jarg2;
32163   if (arg1) (arg1)->z = arg2;
32164 }
32165
32166
32167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32168   int jresult ;
32169   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32170   int result;
32171
32172   arg1 = (Dali::WheelEvent *)jarg1;
32173   result = (int) ((arg1)->z);
32174   jresult = result;
32175   return jresult;
32176 }
32177
32178
32179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32180   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32181   unsigned int arg2 ;
32182
32183   arg1 = (Dali::WheelEvent *)jarg1;
32184   arg2 = (unsigned int)jarg2;
32185   if (arg1) (arg1)->timeStamp = arg2;
32186 }
32187
32188
32189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32190   unsigned int jresult ;
32191   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32192   unsigned int result;
32193
32194   arg1 = (Dali::WheelEvent *)jarg1;
32195   result = (unsigned int) ((arg1)->timeStamp);
32196   jresult = result;
32197   return jresult;
32198 }
32199
32200 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32201   char * jresult ;
32202   Dali::KeyEvent *arg1 = 0 ;
32203   std::string result;
32204
32205   arg1 = (Dali::KeyEvent *)jarg1;
32206   if (!arg1) {
32207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32208     return 0;
32209   }
32210   {
32211     try {
32212       result = arg1->GetDeviceName();
32213     } catch (std::out_of_range& e) {
32214       {
32215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32216       };
32217     } catch (std::exception& e) {
32218       {
32219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32220       };
32221     } catch (Dali::DaliException e) {
32222       {
32223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32224       };
32225     } catch (...) {
32226       {
32227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32228       };
32229     }
32230   }
32231
32232   jresult = SWIG_csharp_string_callback((&result)->c_str());
32233   return jresult;
32234 }
32235
32236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32237   int jresult ;
32238   Dali::KeyEvent *arg1 = 0 ;
32239   Dali::Device::Class::Type result;
32240
32241   arg1 = (Dali::KeyEvent *)jarg1;
32242   if (!arg1) {
32243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32244     return 0;
32245   }
32246   {
32247     try {
32248       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32249     } catch (std::out_of_range& e) {
32250       {
32251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32252       };
32253     } catch (std::exception& e) {
32254       {
32255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32256       };
32257     } catch (Dali::DaliException e) {
32258       {
32259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32260       };
32261     } catch (...) {
32262       {
32263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32264       };
32265     }
32266   }
32267
32268   jresult = (int)result;
32269   return jresult;
32270 }
32271
32272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32273   int jresult ;
32274   Dali::KeyEvent *arg1 = 0 ;
32275   Dali::Device::Subclass::Type result;
32276
32277   arg1 = (Dali::KeyEvent *)jarg1;
32278   if (!arg1) {
32279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32280     return 0;
32281   }
32282   {
32283     try {
32284       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32285     } catch (std::out_of_range& e) {
32286       {
32287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32288       };
32289     } catch (std::exception& e) {
32290       {
32291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32292       };
32293     } catch (Dali::DaliException e) {
32294       {
32295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32296       };
32297     } catch (...) {
32298       {
32299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32300       };
32301     }
32302   }
32303
32304   jresult = (int)result;
32305   return jresult;
32306 }
32307
32308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32309   Dali::Actor arg1 ;
32310   Dali::Actor *argp1 ;
32311
32312   argp1 = (Dali::Actor *)jarg1;
32313   if (!argp1) {
32314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32315     return ;
32316   }
32317   arg1 = *argp1;
32318   {
32319     try {
32320       arg1.Raise();
32321     } catch (std::out_of_range& e) {
32322       {
32323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32324       };
32325     } catch (std::exception& e) {
32326       {
32327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32328       };
32329     } catch (Dali::DaliException e) {
32330       {
32331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32332       };
32333     } catch (...) {
32334       {
32335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32336       };
32337     }
32338   }
32339
32340 }
32341
32342
32343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32344   Dali::Actor arg1 ;
32345   Dali::Actor *argp1 ;
32346
32347   argp1 = (Dali::Actor *)jarg1;
32348   if (!argp1) {
32349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32350     return ;
32351   }
32352   arg1 = *argp1;
32353   {
32354     try {
32355       arg1.Lower();
32356     } catch (std::out_of_range& e) {
32357       {
32358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32359       };
32360     } catch (std::exception& e) {
32361       {
32362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32363       };
32364     } catch (Dali::DaliException e) {
32365       {
32366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32367       };
32368     } catch (...) {
32369       {
32370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32371       };
32372     }
32373   }
32374
32375 }
32376
32377
32378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32379   Dali::Actor arg1 ;
32380   Dali::Actor *argp1 ;
32381
32382   argp1 = (Dali::Actor *)jarg1;
32383   if (!argp1) {
32384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32385     return ;
32386   }
32387   arg1 = *argp1;
32388   {
32389     try {
32390       arg1.RaiseToTop();
32391     } catch (std::out_of_range& e) {
32392       {
32393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32394       };
32395     } catch (std::exception& e) {
32396       {
32397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32398       };
32399     } catch (Dali::DaliException e) {
32400       {
32401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32402       };
32403     } catch (...) {
32404       {
32405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32406       };
32407     }
32408   }
32409
32410 }
32411
32412
32413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32414   Dali::Actor arg1 ;
32415   Dali::Actor *argp1 ;
32416
32417   argp1 = (Dali::Actor *)jarg1;
32418   if (!argp1) {
32419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32420     return ;
32421   }
32422   arg1 = *argp1;
32423   {
32424     try {
32425       arg1.LowerToBottom();
32426     } catch (std::out_of_range& e) {
32427       {
32428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32429       };
32430     } catch (std::exception& e) {
32431       {
32432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32433       };
32434     } catch (Dali::DaliException e) {
32435       {
32436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32437       };
32438     } catch (...) {
32439       {
32440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32441       };
32442     }
32443   }
32444
32445 }
32446
32447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32448   Dali::Actor arg1 ;
32449   Dali::Actor arg2 ;
32450   Dali::Actor *argp1 ;
32451   Dali::Actor *argp2 ;
32452
32453   argp1 = (Dali::Actor *)jarg1;
32454   if (!argp1) {
32455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32456     return ;
32457   }
32458   arg1 = *argp1;
32459   argp2 = (Dali::Actor *)jarg2;
32460   if (!argp2) {
32461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32462     return ;
32463   }
32464   arg2 = *argp2;
32465   {
32466     try {
32467       arg1.RaiseAbove(arg2);
32468     } catch (std::out_of_range& e) {
32469       {
32470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32471       };
32472     } catch (std::exception& e) {
32473       {
32474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32475       };
32476     } catch (Dali::DaliException e) {
32477       {
32478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32479       };
32480     } catch (...) {
32481       {
32482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32483       };
32484     }
32485   }
32486
32487 }
32488
32489
32490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32491   Dali::Actor arg1 ;
32492   Dali::Actor arg2 ;
32493   Dali::Actor *argp1 ;
32494   Dali::Actor *argp2 ;
32495
32496   argp1 = (Dali::Actor *)jarg1;
32497   if (!argp1) {
32498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32499     return ;
32500   }
32501   arg1 = *argp1;
32502   argp2 = (Dali::Actor *)jarg2;
32503   if (!argp2) {
32504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32505     return ;
32506   }
32507   arg2 = *argp2;
32508   {
32509     try {
32510       arg1.LowerBelow(arg2);
32511     } catch (std::out_of_range& e) {
32512       {
32513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32514       };
32515     } catch (std::exception& e) {
32516       {
32517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32518       };
32519     } catch (Dali::DaliException e) {
32520       {
32521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32522       };
32523     } catch (...) {
32524       {
32525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32526       };
32527     }
32528   }
32529
32530 }
32531
32532
32533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32534   void * jresult ;
32535   Dali::Actor arg1 ;
32536   Dali::Actor *argp1 ;
32537   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32538
32539   argp1 = (Dali::Actor *)jarg1;
32540   if (!argp1) {
32541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32542     return 0;
32543   }
32544   arg1 = *argp1;
32545   {
32546     try {
32547       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32548     } catch (std::out_of_range& e) {
32549       {
32550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32551       };
32552     } catch (std::exception& e) {
32553       {
32554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32555       };
32556     } catch (Dali::DaliException e) {
32557       {
32558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32559       };
32560     } catch (...) {
32561       {
32562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32563       };
32564     }
32565   }
32566
32567   jresult = (void *)result;
32568   return jresult;
32569 }
32570
32571
32572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32573   void * jresult ;
32574   Dali::Actor *arg1 ;
32575   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32576
32577   arg1 = (Dali::Actor *)jarg1;
32578   {
32579     try {
32580       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32581     } catch (std::out_of_range& e) {
32582       {
32583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32584       };
32585     } catch (std::exception& e) {
32586       {
32587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32588       };
32589     } catch (Dali::DaliException e) {
32590       {
32591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32592       };
32593     } catch (...) {
32594       {
32595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32596       };
32597     }
32598   }
32599
32600   jresult = (void *)result;
32601   return jresult;
32602 }
32603
32604
32605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32606   int jresult ;
32607   int result;
32608
32609   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32610   jresult = (int)result;
32611   return jresult;
32612 }
32613
32614
32615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32616   int jresult ;
32617   int result;
32618
32619   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32620   jresult = (int)result;
32621   return jresult;
32622 }
32623
32624
32625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32626   int jresult ;
32627   int result;
32628
32629   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32630   jresult = (int)result;
32631   return jresult;
32632 }
32633
32634
32635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32636   int jresult ;
32637   int result;
32638
32639   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32640   jresult = (int)result;
32641   return jresult;
32642 }
32643
32644
32645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32646   int jresult ;
32647   int result;
32648
32649   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32650   jresult = (int)result;
32651   return jresult;
32652 }
32653
32654
32655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32656   int jresult ;
32657   int result;
32658
32659   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32660   jresult = (int)result;
32661   return jresult;
32662 }
32663
32664
32665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32666   int jresult ;
32667   int result;
32668
32669   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32670   jresult = (int)result;
32671   return jresult;
32672 }
32673
32674
32675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32676   int jresult ;
32677   int result;
32678
32679   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32680   jresult = (int)result;
32681   return jresult;
32682 }
32683
32684
32685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32686   int jresult ;
32687   int result;
32688
32689   result = (int)Dali::Actor::Property::SIZE;
32690   jresult = (int)result;
32691   return jresult;
32692 }
32693
32694
32695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32696   int jresult ;
32697   int result;
32698
32699   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32700   jresult = (int)result;
32701   return jresult;
32702 }
32703
32704
32705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32706   int jresult ;
32707   int result;
32708
32709   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32710   jresult = (int)result;
32711   return jresult;
32712 }
32713
32714
32715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32716   int jresult ;
32717   int result;
32718
32719   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32720   jresult = (int)result;
32721   return jresult;
32722 }
32723
32724
32725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32726   int jresult ;
32727   int result;
32728
32729   result = (int)Dali::Actor::Property::POSITION;
32730   jresult = (int)result;
32731   return jresult;
32732 }
32733
32734
32735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32736   int jresult ;
32737   int result;
32738
32739   result = (int)Dali::Actor::Property::POSITION_X;
32740   jresult = (int)result;
32741   return jresult;
32742 }
32743
32744
32745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32746   int jresult ;
32747   int result;
32748
32749   result = (int)Dali::Actor::Property::POSITION_Y;
32750   jresult = (int)result;
32751   return jresult;
32752 }
32753
32754
32755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32756   int jresult ;
32757   int result;
32758
32759   result = (int)Dali::Actor::Property::POSITION_Z;
32760   jresult = (int)result;
32761   return jresult;
32762 }
32763
32764
32765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
32766   int jresult ;
32767   int result;
32768
32769   result = (int)Dali::Actor::Property::WORLD_POSITION;
32770   jresult = (int)result;
32771   return jresult;
32772 }
32773
32774
32775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
32776   int jresult ;
32777   int result;
32778
32779   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
32780   jresult = (int)result;
32781   return jresult;
32782 }
32783
32784
32785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
32786   int jresult ;
32787   int result;
32788
32789   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
32790   jresult = (int)result;
32791   return jresult;
32792 }
32793
32794
32795 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
32796   int jresult ;
32797   int result;
32798
32799   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
32800   jresult = (int)result;
32801   return jresult;
32802 }
32803
32804
32805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
32806   int jresult ;
32807   int result;
32808
32809   result = (int)Dali::Actor::Property::ORIENTATION;
32810   jresult = (int)result;
32811   return jresult;
32812 }
32813
32814
32815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
32816   int jresult ;
32817   int result;
32818
32819   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
32820   jresult = (int)result;
32821   return jresult;
32822 }
32823
32824
32825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
32826   int jresult ;
32827   int result;
32828
32829   result = (int)Dali::Actor::Property::SCALE;
32830   jresult = (int)result;
32831   return jresult;
32832 }
32833
32834
32835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
32836   int jresult ;
32837   int result;
32838
32839   result = (int)Dali::Actor::Property::SCALE_X;
32840   jresult = (int)result;
32841   return jresult;
32842 }
32843
32844
32845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
32846   int jresult ;
32847   int result;
32848
32849   result = (int)Dali::Actor::Property::SCALE_Y;
32850   jresult = (int)result;
32851   return jresult;
32852 }
32853
32854
32855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
32856   int jresult ;
32857   int result;
32858
32859   result = (int)Dali::Actor::Property::SCALE_Z;
32860   jresult = (int)result;
32861   return jresult;
32862 }
32863
32864
32865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
32866   int jresult ;
32867   int result;
32868
32869   result = (int)Dali::Actor::Property::WORLD_SCALE;
32870   jresult = (int)result;
32871   return jresult;
32872 }
32873
32874
32875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
32876   int jresult ;
32877   int result;
32878
32879   result = (int)Dali::Actor::Property::VISIBLE;
32880   jresult = (int)result;
32881   return jresult;
32882 }
32883
32884
32885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
32886   int jresult ;
32887   int result;
32888
32889   result = (int)Dali::Actor::Property::COLOR;
32890   jresult = (int)result;
32891   return jresult;
32892 }
32893
32894
32895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
32896   int jresult ;
32897   int result;
32898
32899   result = (int)Dali::Actor::Property::COLOR_RED;
32900   jresult = (int)result;
32901   return jresult;
32902 }
32903
32904
32905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
32906   int jresult ;
32907   int result;
32908
32909   result = (int)Dali::Actor::Property::COLOR_GREEN;
32910   jresult = (int)result;
32911   return jresult;
32912 }
32913
32914
32915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
32916   int jresult ;
32917   int result;
32918
32919   result = (int)Dali::Actor::Property::COLOR_BLUE;
32920   jresult = (int)result;
32921   return jresult;
32922 }
32923
32924
32925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
32926   int jresult ;
32927   int result;
32928
32929   result = (int)Dali::Actor::Property::COLOR_ALPHA;
32930   jresult = (int)result;
32931   return jresult;
32932 }
32933
32934
32935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
32936   int jresult ;
32937   int result;
32938
32939   result = (int)Dali::Actor::Property::WORLD_COLOR;
32940   jresult = (int)result;
32941   return jresult;
32942 }
32943
32944
32945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
32946   int jresult ;
32947   int result;
32948
32949   result = (int)Dali::Actor::Property::WORLD_MATRIX;
32950   jresult = (int)result;
32951   return jresult;
32952 }
32953
32954
32955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
32956   int jresult ;
32957   int result;
32958
32959   result = (int)Dali::Actor::Property::NAME;
32960   jresult = (int)result;
32961   return jresult;
32962 }
32963
32964
32965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
32966   int jresult ;
32967   int result;
32968
32969   result = (int)Dali::Actor::Property::SENSITIVE;
32970   jresult = (int)result;
32971   return jresult;
32972 }
32973
32974
32975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
32976   int jresult ;
32977   int result;
32978
32979   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
32980   jresult = (int)result;
32981   return jresult;
32982 }
32983
32984
32985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
32986   int jresult ;
32987   int result;
32988
32989   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
32990   jresult = (int)result;
32991   return jresult;
32992 }
32993
32994
32995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
32996   int jresult ;
32997   int result;
32998
32999   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33000   jresult = (int)result;
33001   return jresult;
33002 }
33003
33004
33005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33006   int jresult ;
33007   int result;
33008
33009   result = (int)Dali::Actor::Property::COLOR_MODE;
33010   jresult = (int)result;
33011   return jresult;
33012 }
33013
33014
33015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33016   int jresult ;
33017   int result;
33018
33019   result = (int)Dali::Actor::Property::DRAW_MODE;
33020   jresult = (int)result;
33021   return jresult;
33022 }
33023
33024
33025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33026   int jresult ;
33027   int result;
33028
33029   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33030   jresult = (int)result;
33031   return jresult;
33032 }
33033
33034
33035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33036   int jresult ;
33037   int result;
33038
33039   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33040   jresult = (int)result;
33041   return jresult;
33042 }
33043
33044
33045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33046   int jresult ;
33047   int result;
33048
33049   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33050   jresult = (int)result;
33051   return jresult;
33052 }
33053
33054
33055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33056   int jresult ;
33057   int result;
33058
33059   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33060   jresult = (int)result;
33061   return jresult;
33062 }
33063
33064
33065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33066   int jresult ;
33067   int result;
33068
33069   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33070   jresult = (int)result;
33071   return jresult;
33072 }
33073
33074
33075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33076   int jresult ;
33077   int result;
33078
33079   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33080   jresult = (int)result;
33081   return jresult;
33082 }
33083
33084
33085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33086   int jresult ;
33087   int result;
33088
33089   result = (int)Dali::Actor::Property::PADDING;
33090   jresult = (int)result;
33091   return jresult;
33092 }
33093
33094
33095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33096   int jresult ;
33097   int result;
33098
33099   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33100   jresult = (int)result;
33101   return jresult;
33102 }
33103
33104
33105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33106   int jresult ;
33107   int result;
33108
33109   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33110   jresult = (int)result;
33111   return jresult;
33112 }
33113
33114
33115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33116   int jresult ;
33117   int result;
33118
33119   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33120   jresult = (int)result;
33121   return jresult;
33122 }
33123
33124
33125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33126   int jresult ;
33127   int result;
33128
33129   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33130   jresult = (int)result;
33131   return jresult;
33132 }
33133
33134 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
33135
33136   return Dali::Actor::Property::OPACITY;
33137 }
33138
33139 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
33140
33141   return Dali::Actor::Property::SCREEN_POSITION;
33142 }
33143
33144 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
33145
33146   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
33147 }
33148
33149 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
33150   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
33151 }
33152
33153 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
33154   return Dali::Actor::Property::LAYOUT_DIRECTION;
33155 }
33156
33157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33158   void * jresult ;
33159   Dali::Actor::Property *result = 0 ;
33160
33161   {
33162     try {
33163       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33164     } catch (std::out_of_range& e) {
33165       {
33166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33167       };
33168     } catch (std::exception& e) {
33169       {
33170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33171       };
33172     } catch (Dali::DaliException e) {
33173       {
33174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33175       };
33176     } catch (...) {
33177       {
33178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33179       };
33180     }
33181   }
33182
33183   jresult = (void *)result;
33184   return jresult;
33185 }
33186
33187
33188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33189   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33190
33191   arg1 = (Dali::Actor::Property *)jarg1;
33192   {
33193     try {
33194       delete arg1;
33195     } catch (std::out_of_range& e) {
33196       {
33197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33198       };
33199     } catch (std::exception& e) {
33200       {
33201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33202       };
33203     } catch (Dali::DaliException e) {
33204       {
33205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33206       };
33207     } catch (...) {
33208       {
33209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33210       };
33211     }
33212   }
33213
33214 }
33215
33216
33217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33218   void * jresult ;
33219   Dali::Actor *result = 0 ;
33220
33221   {
33222     try {
33223       result = (Dali::Actor *)new Dali::Actor();
33224     } catch (std::out_of_range& e) {
33225       {
33226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33227       };
33228     } catch (std::exception& e) {
33229       {
33230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33231       };
33232     } catch (Dali::DaliException e) {
33233       {
33234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33235       };
33236     } catch (...) {
33237       {
33238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33239       };
33240     }
33241   }
33242
33243   jresult = (void *)result;
33244   return jresult;
33245 }
33246
33247
33248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33249   void * jresult ;
33250   Dali::Actor result;
33251
33252   {
33253     try {
33254       result = Dali::Actor::New();
33255     } catch (std::out_of_range& e) {
33256       {
33257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33258       };
33259     } catch (std::exception& e) {
33260       {
33261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33262       };
33263     } catch (Dali::DaliException e) {
33264       {
33265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33266       };
33267     } catch (...) {
33268       {
33269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33270       };
33271     }
33272   }
33273
33274   jresult = new Dali::Actor((const Dali::Actor &)result);
33275   return jresult;
33276 }
33277
33278
33279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33280   void * jresult ;
33281   Dali::BaseHandle arg1 ;
33282   Dali::BaseHandle *argp1 ;
33283   Dali::Actor result;
33284
33285   argp1 = (Dali::BaseHandle *)jarg1;
33286   if (!argp1) {
33287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33288     return 0;
33289   }
33290   arg1 = *argp1;
33291   {
33292     try {
33293       result = Dali::Actor::DownCast(arg1);
33294     } catch (std::out_of_range& e) {
33295       {
33296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33297       };
33298     } catch (std::exception& e) {
33299       {
33300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33301       };
33302     } catch (Dali::DaliException e) {
33303       {
33304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33305       };
33306     } catch (...) {
33307       {
33308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33309       };
33310     }
33311   }
33312
33313   jresult = new Dali::Actor((const Dali::Actor &)result);
33314   return jresult;
33315 }
33316
33317
33318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33319   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33320
33321   arg1 = (Dali::Actor *)jarg1;
33322   {
33323     try {
33324       delete arg1;
33325     } catch (std::out_of_range& e) {
33326       {
33327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33328       };
33329     } catch (std::exception& e) {
33330       {
33331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33332       };
33333     } catch (Dali::DaliException e) {
33334       {
33335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33336       };
33337     } catch (...) {
33338       {
33339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33340       };
33341     }
33342   }
33343
33344 }
33345
33346
33347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33348   void * jresult ;
33349   Dali::Actor *arg1 = 0 ;
33350   Dali::Actor *result = 0 ;
33351
33352   arg1 = (Dali::Actor *)jarg1;
33353   if (!arg1) {
33354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33355     return 0;
33356   }
33357   {
33358     try {
33359       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33360     } catch (std::out_of_range& e) {
33361       {
33362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33363       };
33364     } catch (std::exception& e) {
33365       {
33366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33367       };
33368     } catch (Dali::DaliException e) {
33369       {
33370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33371       };
33372     } catch (...) {
33373       {
33374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33375       };
33376     }
33377   }
33378
33379   jresult = (void *)result;
33380   return jresult;
33381 }
33382
33383
33384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33385   void * jresult ;
33386   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33387   Dali::Actor *arg2 = 0 ;
33388   Dali::Actor *result = 0 ;
33389
33390   arg1 = (Dali::Actor *)jarg1;
33391   arg2 = (Dali::Actor *)jarg2;
33392   if (!arg2) {
33393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33394     return 0;
33395   }
33396   {
33397     try {
33398       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33399     } catch (std::out_of_range& e) {
33400       {
33401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33402       };
33403     } catch (std::exception& e) {
33404       {
33405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33406       };
33407     } catch (Dali::DaliException e) {
33408       {
33409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33410       };
33411     } catch (...) {
33412       {
33413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33414       };
33415     }
33416   }
33417
33418   jresult = (void *)result;
33419   return jresult;
33420 }
33421
33422
33423 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33424   char * jresult ;
33425   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33426   std::string *result = 0 ;
33427   std::string name = "";
33428
33429   arg1 = (Dali::Actor *)jarg1;
33430   {
33431     try {
33432       name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
33433       result = (std::string *) &name;
33434       jresult = SWIG_csharp_string_callback(result->c_str());
33435     } catch (std::out_of_range& e) {
33436       {
33437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33438       };
33439     } catch (std::exception& e) {
33440       {
33441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33442       };
33443     } catch (Dali::DaliException e) {
33444       {
33445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33446       };
33447     } catch (...) {
33448       {
33449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33450       };
33451     }
33452   }
33453   return jresult;
33454 }
33455
33456
33457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33458   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33459   std::string *arg2 = 0 ;
33460
33461   arg1 = (Dali::Actor *)jarg1;
33462   if (!jarg2) {
33463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33464     return ;
33465   }
33466   std::string arg2_str(jarg2);
33467   arg2 = &arg2_str;
33468   {
33469     try {
33470       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
33471     } catch (std::out_of_range& e) {
33472       {
33473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33474       };
33475     } catch (std::exception& e) {
33476       {
33477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33478       };
33479     } catch (Dali::DaliException e) {
33480       {
33481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33482       };
33483     } catch (...) {
33484       {
33485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33486       };
33487     }
33488   }
33489
33490
33491   //argout typemap for const std::string&
33492
33493 }
33494
33495
33496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33497   unsigned int jresult ;
33498   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33499   unsigned int result;
33500
33501   arg1 = (Dali::Actor *)jarg1;
33502
33503   if(!arg1) {
33504     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33505     return -1;
33506   }
33507
33508   {
33509     try {
33510       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
33511     } catch (std::out_of_range& e) {
33512       {
33513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33514       };
33515     } catch (std::exception& e) {
33516       {
33517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33518       };
33519     } catch (Dali::DaliException e) {
33520       {
33521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33522       };
33523     } catch (...) {
33524       {
33525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33526       };
33527     }
33528   }
33529
33530   jresult = result;
33531   return jresult;
33532 }
33533
33534
33535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33536   unsigned int jresult ;
33537   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33538   bool result;
33539
33540   arg1 = (Dali::Actor *)jarg1;
33541   {
33542     try {
33543       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
33544     } catch (std::out_of_range& e) {
33545       {
33546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33547       };
33548     } catch (std::exception& e) {
33549       {
33550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33551       };
33552     } catch (Dali::DaliException e) {
33553       {
33554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33555       };
33556     } catch (...) {
33557       {
33558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33559       };
33560     }
33561   }
33562
33563   jresult = result;
33564   return jresult;
33565 }
33566
33567
33568 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33569   unsigned int jresult ;
33570   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33571   bool result;
33572
33573   arg1 = (Dali::Actor *)jarg1;
33574   {
33575     try {
33576       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
33577     } catch (std::out_of_range& e) {
33578       {
33579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33580       };
33581     } catch (std::exception& e) {
33582       {
33583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33584       };
33585     } catch (Dali::DaliException e) {
33586       {
33587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33588       };
33589     } catch (...) {
33590       {
33591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33592       };
33593     }
33594   }
33595
33596   jresult = result;
33597   return jresult;
33598 }
33599
33600
33601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33602   unsigned int jresult ;
33603   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33604   bool result;
33605
33606   arg1 = (Dali::Actor *)jarg1;
33607   {
33608     try {
33609       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
33610     } catch (std::out_of_range& e) {
33611       {
33612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33613       };
33614     } catch (std::exception& e) {
33615       {
33616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33617       };
33618     } catch (Dali::DaliException e) {
33619       {
33620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33621       };
33622     } catch (...) {
33623       {
33624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33625       };
33626     }
33627   }
33628
33629   jresult = result;
33630   return jresult;
33631 }
33632
33633
33634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33635   void * jresult ;
33636   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33637   Dali::Layer result;
33638
33639   arg1 = (Dali::Actor *)jarg1;
33640   {
33641     try {
33642       result = (arg1)->GetLayer();
33643     } catch (std::out_of_range& e) {
33644       {
33645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33646       };
33647     } catch (std::exception& e) {
33648       {
33649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33650       };
33651     } catch (Dali::DaliException e) {
33652       {
33653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33654       };
33655     } catch (...) {
33656       {
33657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33658       };
33659     }
33660   }
33661
33662   jresult = new Dali::Layer((const Dali::Layer &)result);
33663   return jresult;
33664 }
33665
33666
33667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33668   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33669   Dali::Actor arg2 ;
33670   Dali::Actor *argp2 ;
33671
33672   arg1 = (Dali::Actor *)jarg1;
33673   argp2 = (Dali::Actor *)jarg2;
33674   if (!argp2) {
33675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33676     return ;
33677   }
33678   arg2 = *argp2;
33679   {
33680     try {
33681       (arg1)->Add(arg2);
33682     } catch (std::out_of_range& e) {
33683       {
33684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33685       };
33686     } catch (std::exception& e) {
33687       {
33688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33689       };
33690     } catch (Dali::DaliException e) {
33691       {
33692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33693       };
33694     } catch (...) {
33695       {
33696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33697       };
33698     }
33699   }
33700
33701 }
33702
33703
33704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33705   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33706   Dali::Actor arg2 ;
33707   Dali::Actor *argp2 ;
33708
33709   arg1 = (Dali::Actor *)jarg1;
33710   argp2 = (Dali::Actor *)jarg2;
33711   if (!argp2) {
33712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33713     return ;
33714   }
33715   arg2 = *argp2;
33716   {
33717     try {
33718       (arg1)->Remove(arg2);
33719     } catch (std::out_of_range& e) {
33720       {
33721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33722       };
33723     } catch (std::exception& e) {
33724       {
33725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33726       };
33727     } catch (Dali::DaliException e) {
33728       {
33729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33730       };
33731     } catch (...) {
33732       {
33733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33734       };
33735     }
33736   }
33737
33738 }
33739
33740
33741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33742   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33743
33744   arg1 = (Dali::Actor *)jarg1;
33745   {
33746     try {
33747       (arg1)->Unparent();
33748     } catch (std::out_of_range& e) {
33749       {
33750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33751       };
33752     } catch (std::exception& e) {
33753       {
33754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33755       };
33756     } catch (Dali::DaliException e) {
33757       {
33758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33759       };
33760     } catch (...) {
33761       {
33762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33763       };
33764     }
33765   }
33766
33767 }
33768
33769
33770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33771   unsigned int jresult ;
33772   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33773   unsigned int result;
33774
33775   arg1 = (Dali::Actor *)jarg1;
33776   {
33777     try {
33778       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33779     } catch (std::out_of_range& e) {
33780       {
33781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33782       };
33783     } catch (std::exception& e) {
33784       {
33785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33786       };
33787     } catch (Dali::DaliException e) {
33788       {
33789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33790       };
33791     } catch (...) {
33792       {
33793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33794       };
33795     }
33796   }
33797
33798   jresult = result;
33799   return jresult;
33800 }
33801
33802
33803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
33804   void * jresult ;
33805   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33806   unsigned int arg2 ;
33807   Dali::Actor result;
33808
33809   arg1 = (Dali::Actor *)jarg1;
33810   arg2 = (unsigned int)jarg2;
33811   {
33812     try {
33813       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
33814     } catch (std::out_of_range& e) {
33815       {
33816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33817       };
33818     } catch (std::exception& e) {
33819       {
33820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33821       };
33822     } catch (Dali::DaliException e) {
33823       {
33824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33825       };
33826     } catch (...) {
33827       {
33828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33829       };
33830     }
33831   }
33832
33833   jresult = new Dali::Actor((const Dali::Actor &)result);
33834   return jresult;
33835 }
33836
33837
33838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
33839   void * jresult ;
33840   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33841   std::string *arg2 = 0 ;
33842   Dali::Actor result;
33843
33844   arg1 = (Dali::Actor *)jarg1;
33845   if (!jarg2) {
33846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33847     return 0;
33848   }
33849   std::string arg2_str(jarg2);
33850   arg2 = &arg2_str;
33851   {
33852     try {
33853       result = (arg1)->FindChildByName((std::string const &)*arg2);
33854     } catch (std::out_of_range& e) {
33855       {
33856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33857       };
33858     } catch (std::exception& e) {
33859       {
33860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33861       };
33862     } catch (Dali::DaliException e) {
33863       {
33864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33865       };
33866     } catch (...) {
33867       {
33868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33869       };
33870     }
33871   }
33872
33873   jresult = new Dali::Actor((const Dali::Actor &)result);
33874
33875   //argout typemap for const std::string&
33876
33877   return jresult;
33878 }
33879
33880
33881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
33882   void * jresult ;
33883   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33884   unsigned int arg2 ;
33885   Dali::Actor result;
33886
33887   arg1 = (Dali::Actor *)jarg1;
33888   arg2 = (unsigned int)jarg2;
33889   {
33890     try {
33891       result = (arg1)->FindChildById(arg2);
33892     } catch (std::out_of_range& e) {
33893       {
33894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33895       };
33896     } catch (std::exception& e) {
33897       {
33898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33899       };
33900     } catch (Dali::DaliException e) {
33901       {
33902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33903       };
33904     } catch (...) {
33905       {
33906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33907       };
33908     }
33909   }
33910
33911   jresult = new Dali::Actor((const Dali::Actor &)result);
33912   return jresult;
33913 }
33914
33915
33916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
33917   void * jresult ;
33918   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33919   Dali::Actor result;
33920
33921   arg1 = (Dali::Actor *)jarg1;
33922   {
33923     try {
33924       result = ((Dali::Actor const *)arg1)->GetParent();
33925     } catch (std::out_of_range& e) {
33926       {
33927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33928       };
33929     } catch (std::exception& e) {
33930       {
33931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33932       };
33933     } catch (Dali::DaliException e) {
33934       {
33935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33936       };
33937     } catch (...) {
33938       {
33939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33940       };
33941     }
33942   }
33943
33944   jresult = new Dali::Actor((const Dali::Actor &)result);
33945   return jresult;
33946 }
33947
33948
33949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
33950   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33951   Dali::Vector3 *arg2 = 0 ;
33952
33953   arg1 = (Dali::Actor *)jarg1;
33954   arg2 = (Dali::Vector3 *)jarg2;
33955   if (!arg2) {
33956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
33957     return ;
33958   }
33959   {
33960     try {
33961       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
33962     } catch (std::out_of_range& e) {
33963       {
33964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33965       };
33966     } catch (std::exception& e) {
33967       {
33968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33969       };
33970     } catch (Dali::DaliException e) {
33971       {
33972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33973       };
33974     } catch (...) {
33975       {
33976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33977       };
33978     }
33979   }
33980
33981 }
33982
33983
33984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
33985   void * jresult ;
33986   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33987   Dali::Vector3 result;
33988
33989   arg1 = (Dali::Actor *)jarg1;
33990   {
33991     try {
33992       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
33993     } catch (std::out_of_range& e) {
33994       {
33995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33996       };
33997     } catch (std::exception& e) {
33998       {
33999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34000       };
34001     } catch (Dali::DaliException e) {
34002       {
34003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34004       };
34005     } catch (...) {
34006       {
34007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34008       };
34009     }
34010   }
34011
34012   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34013   return jresult;
34014 }
34015
34016
34017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34018   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34019   Dali::Vector3 *arg2 = 0 ;
34020
34021   arg1 = (Dali::Actor *)jarg1;
34022   arg2 = (Dali::Vector3 *)jarg2;
34023   if (!arg2) {
34024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34025     return ;
34026   }
34027   {
34028     try {
34029       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
34030     } catch (std::out_of_range& e) {
34031       {
34032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34033       };
34034     } catch (std::exception& e) {
34035       {
34036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34037       };
34038     } catch (Dali::DaliException e) {
34039       {
34040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34041       };
34042     } catch (...) {
34043       {
34044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34045       };
34046     }
34047   }
34048
34049 }
34050
34051
34052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34053   void * jresult ;
34054   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34055   Dali::Vector3 result;
34056
34057   arg1 = (Dali::Actor *)jarg1;
34058   {
34059     try {
34060       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
34061     } catch (std::out_of_range& e) {
34062       {
34063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34064       };
34065     } catch (std::exception& e) {
34066       {
34067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34068       };
34069     } catch (Dali::DaliException e) {
34070       {
34071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34072       };
34073     } catch (...) {
34074       {
34075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34076       };
34077     }
34078   }
34079
34080   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34081   return jresult;
34082 }
34083
34084
34085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34086   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34087   float arg2 ;
34088   float arg3 ;
34089
34090   arg1 = (Dali::Actor *)jarg1;
34091   arg2 = (float)jarg2;
34092   arg3 = (float)jarg3;
34093   {
34094     try {
34095       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
34096     } catch (std::out_of_range& e) {
34097       {
34098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34099       };
34100     } catch (std::exception& e) {
34101       {
34102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34103       };
34104     } catch (Dali::DaliException e) {
34105       {
34106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34107       };
34108     } catch (...) {
34109       {
34110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34111       };
34112     }
34113   }
34114
34115 }
34116
34117
34118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34119   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34120   float arg2 ;
34121   float arg3 ;
34122   float arg4 ;
34123
34124   arg1 = (Dali::Actor *)jarg1;
34125   arg2 = (float)jarg2;
34126   arg3 = (float)jarg3;
34127   arg4 = (float)jarg4;
34128   {
34129     try {
34130       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
34131     } catch (std::out_of_range& e) {
34132       {
34133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34134       };
34135     } catch (std::exception& e) {
34136       {
34137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34138       };
34139     } catch (Dali::DaliException e) {
34140       {
34141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34142       };
34143     } catch (...) {
34144       {
34145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34146       };
34147     }
34148   }
34149
34150 }
34151
34152
34153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34154   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34155   Dali::Vector2 *arg2 = 0 ;
34156
34157   arg1 = (Dali::Actor *)jarg1;
34158   arg2 = (Dali::Vector2 *)jarg2;
34159   if (!arg2) {
34160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34161     return ;
34162   }
34163   {
34164     try {
34165       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
34166     } catch (std::out_of_range& e) {
34167       {
34168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34169       };
34170     } catch (std::exception& e) {
34171       {
34172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34173       };
34174     } catch (Dali::DaliException e) {
34175       {
34176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34177       };
34178     } catch (...) {
34179       {
34180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34181       };
34182     }
34183   }
34184
34185 }
34186
34187
34188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34189   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34190   Dali::Vector3 *arg2 = 0 ;
34191
34192   arg1 = (Dali::Actor *)jarg1;
34193   arg2 = (Dali::Vector3 *)jarg2;
34194   if (!arg2) {
34195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34196     return ;
34197   }
34198   {
34199     try {
34200       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
34201     } catch (std::out_of_range& e) {
34202       {
34203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34204       };
34205     } catch (std::exception& e) {
34206       {
34207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34208       };
34209     } catch (Dali::DaliException e) {
34210       {
34211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34212       };
34213     } catch (...) {
34214       {
34215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34216       };
34217     }
34218   }
34219
34220 }
34221
34222
34223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34224   void * jresult ;
34225   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34226   Dali::Vector3 result;
34227
34228   arg1 = (Dali::Actor *)jarg1;
34229   {
34230     try {
34231       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34232     } catch (std::out_of_range& e) {
34233       {
34234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34235       };
34236     } catch (std::exception& e) {
34237       {
34238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34239       };
34240     } catch (Dali::DaliException e) {
34241       {
34242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34243       };
34244     } catch (...) {
34245       {
34246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34247       };
34248     }
34249   }
34250
34251   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34252   return jresult;
34253 }
34254
34255
34256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34257   void * jresult ;
34258   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34259   Dali::Vector3 result;
34260
34261   arg1 = (Dali::Actor *)jarg1;
34262   {
34263     try {
34264       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
34265     } catch (std::out_of_range& e) {
34266       {
34267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34268       };
34269     } catch (std::exception& e) {
34270       {
34271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34272       };
34273     } catch (Dali::DaliException e) {
34274       {
34275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34276       };
34277     } catch (...) {
34278       {
34279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34280       };
34281     }
34282   }
34283
34284   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34285   return jresult;
34286 }
34287
34288
34289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34290   void * jresult ;
34291   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34292   Dali::Vector3 result;
34293
34294   arg1 = (Dali::Actor *)jarg1;
34295   {
34296     try {
34297       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34298     } catch (std::out_of_range& e) {
34299       {
34300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34301       };
34302     } catch (std::exception& e) {
34303       {
34304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34305       };
34306     } catch (Dali::DaliException e) {
34307       {
34308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34309       };
34310     } catch (...) {
34311       {
34312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34313       };
34314     }
34315   }
34316
34317   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34318   return jresult;
34319 }
34320
34321
34322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34323   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34324   float arg2 ;
34325   float arg3 ;
34326
34327   arg1 = (Dali::Actor *)jarg1;
34328   arg2 = (float)jarg2;
34329   arg3 = (float)jarg3;
34330   {
34331     try {
34332       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
34333     } catch (std::out_of_range& e) {
34334       {
34335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34336       };
34337     } catch (std::exception& e) {
34338       {
34339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34340       };
34341     } catch (Dali::DaliException e) {
34342       {
34343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34344       };
34345     } catch (...) {
34346       {
34347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34348       };
34349     }
34350   }
34351
34352 }
34353
34354
34355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34356   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34357   float arg2 ;
34358   float arg3 ;
34359   float arg4 ;
34360
34361   arg1 = (Dali::Actor *)jarg1;
34362   arg2 = (float)jarg2;
34363   arg3 = (float)jarg3;
34364   arg4 = (float)jarg4;
34365   {
34366     try {
34367       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
34368     } catch (std::out_of_range& e) {
34369       {
34370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34371       };
34372     } catch (std::exception& e) {
34373       {
34374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34375       };
34376     } catch (Dali::DaliException e) {
34377       {
34378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34379       };
34380     } catch (...) {
34381       {
34382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34383       };
34384     }
34385   }
34386
34387 }
34388
34389
34390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34391   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34392   Dali::Vector3 *arg2 = 0 ;
34393
34394   arg1 = (Dali::Actor *)jarg1;
34395   arg2 = (Dali::Vector3 *)jarg2;
34396   if (!arg2) {
34397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34398     return ;
34399   }
34400   {
34401     try {
34402       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
34403     } catch (std::out_of_range& e) {
34404       {
34405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34406       };
34407     } catch (std::exception& e) {
34408       {
34409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34410       };
34411     } catch (Dali::DaliException e) {
34412       {
34413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34414       };
34415     } catch (...) {
34416       {
34417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34418       };
34419     }
34420   }
34421
34422 }
34423
34424
34425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34426   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34427   float arg2 ;
34428
34429   arg1 = (Dali::Actor *)jarg1;
34430   arg2 = (float)jarg2;
34431   {
34432     try {
34433       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
34434     } catch (std::out_of_range& e) {
34435       {
34436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34437       };
34438     } catch (std::exception& e) {
34439       {
34440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34441       };
34442     } catch (Dali::DaliException e) {
34443       {
34444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34445       };
34446     } catch (...) {
34447       {
34448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34449       };
34450     }
34451   }
34452
34453 }
34454
34455
34456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34457   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34458   float arg2 ;
34459
34460   arg1 = (Dali::Actor *)jarg1;
34461   arg2 = (float)jarg2;
34462   {
34463     try {
34464       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
34465     } catch (std::out_of_range& e) {
34466       {
34467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34468       };
34469     } catch (std::exception& e) {
34470       {
34471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34472       };
34473     } catch (Dali::DaliException e) {
34474       {
34475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34476       };
34477     } catch (...) {
34478       {
34479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34480       };
34481     }
34482   }
34483
34484 }
34485
34486
34487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34488   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34489   float arg2 ;
34490
34491   arg1 = (Dali::Actor *)jarg1;
34492   arg2 = (float)jarg2;
34493   {
34494     try {
34495       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
34496     } catch (std::out_of_range& e) {
34497       {
34498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34499       };
34500     } catch (std::exception& e) {
34501       {
34502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34503       };
34504     } catch (Dali::DaliException e) {
34505       {
34506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34507       };
34508     } catch (...) {
34509       {
34510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34511       };
34512     }
34513   }
34514
34515 }
34516
34517
34518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34519   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34520   Dali::Vector3 *arg2 = 0 ;
34521
34522   arg1 = (Dali::Actor *)jarg1;
34523   arg2 = (Dali::Vector3 *)jarg2;
34524   if (!arg2) {
34525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34526     return ;
34527   }
34528   {
34529     try {
34530       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34531     } catch (std::out_of_range& e) {
34532       {
34533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34534       };
34535     } catch (std::exception& e) {
34536       {
34537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34538       };
34539     } catch (Dali::DaliException e) {
34540       {
34541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34542       };
34543     } catch (...) {
34544       {
34545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34546       };
34547     }
34548   }
34549
34550 }
34551
34552
34553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34554   void * jresult ;
34555   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34556   Dali::Vector3 result;
34557
34558   arg1 = (Dali::Actor *)jarg1;
34559   {
34560     try {
34561       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
34562     } catch (std::out_of_range& e) {
34563       {
34564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34565       };
34566     } catch (std::exception& e) {
34567       {
34568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34569       };
34570     } catch (Dali::DaliException e) {
34571       {
34572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34573       };
34574     } catch (...) {
34575       {
34576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34577       };
34578     }
34579   }
34580
34581   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34582   return jresult;
34583 }
34584
34585
34586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34587   void * jresult ;
34588   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34589   Dali::Vector3 result;
34590
34591   arg1 = (Dali::Actor *)jarg1;
34592   {
34593     try {
34594       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
34595     } catch (std::out_of_range& e) {
34596       {
34597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34598       };
34599     } catch (std::exception& e) {
34600       {
34601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34602       };
34603     } catch (Dali::DaliException e) {
34604       {
34605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34606       };
34607     } catch (...) {
34608       {
34609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34610       };
34611     }
34612   }
34613
34614   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34615   return jresult;
34616 }
34617
34618
34619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34620   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34621   bool arg2 ;
34622
34623   arg1 = (Dali::Actor *)jarg1;
34624   arg2 = jarg2 ? true : false;
34625   {
34626     try {
34627       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
34628     } catch (std::out_of_range& e) {
34629       {
34630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34631       };
34632     } catch (std::exception& e) {
34633       {
34634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34635       };
34636     } catch (Dali::DaliException e) {
34637       {
34638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34639       };
34640     } catch (...) {
34641       {
34642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34643       };
34644     }
34645   }
34646
34647 }
34648
34649
34650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34651   unsigned int jresult ;
34652   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34653   bool result;
34654
34655   arg1 = (Dali::Actor *)jarg1;
34656   {
34657     try {
34658       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
34659     } catch (std::out_of_range& e) {
34660       {
34661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34662       };
34663     } catch (std::exception& e) {
34664       {
34665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34666       };
34667     } catch (Dali::DaliException e) {
34668       {
34669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34670       };
34671     } catch (...) {
34672       {
34673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34674       };
34675     }
34676   }
34677
34678   jresult = result;
34679   return jresult;
34680 }
34681
34682
34683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34684   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34685   Dali::Degree *arg2 = 0 ;
34686   Dali::Vector3 *arg3 = 0 ;
34687
34688   arg1 = (Dali::Actor *)jarg1;
34689   arg2 = (Dali::Degree *)jarg2;
34690   if (!arg2) {
34691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34692     return ;
34693   }
34694   arg3 = (Dali::Vector3 *)jarg3;
34695   if (!arg3) {
34696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34697     return ;
34698   }
34699   {
34700     try {
34701       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34702     } catch (std::out_of_range& e) {
34703       {
34704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34705       };
34706     } catch (std::exception& e) {
34707       {
34708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34709       };
34710     } catch (Dali::DaliException e) {
34711       {
34712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34713       };
34714     } catch (...) {
34715       {
34716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34717       };
34718     }
34719   }
34720
34721 }
34722
34723
34724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34725   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34726   Dali::Radian *arg2 = 0 ;
34727   Dali::Vector3 *arg3 = 0 ;
34728
34729   arg1 = (Dali::Actor *)jarg1;
34730   arg2 = (Dali::Radian *)jarg2;
34731   if (!arg2) {
34732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34733     return ;
34734   }
34735   arg3 = (Dali::Vector3 *)jarg3;
34736   if (!arg3) {
34737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34738     return ;
34739   }
34740   {
34741     try {
34742       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34743     } catch (std::out_of_range& e) {
34744       {
34745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34746       };
34747     } catch (std::exception& e) {
34748       {
34749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34750       };
34751     } catch (Dali::DaliException e) {
34752       {
34753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34754       };
34755     } catch (...) {
34756       {
34757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34758       };
34759     }
34760   }
34761
34762 }
34763
34764
34765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34766   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34767   Dali::Quaternion *arg2 = 0 ;
34768
34769   arg1 = (Dali::Actor *)jarg1;
34770   arg2 = (Dali::Quaternion *)jarg2;
34771   if (!arg2) {
34772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34773     return ;
34774   }
34775   {
34776     try {
34777       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
34778     } catch (std::out_of_range& e) {
34779       {
34780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34781       };
34782     } catch (std::exception& e) {
34783       {
34784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34785       };
34786     } catch (Dali::DaliException e) {
34787       {
34788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34789       };
34790     } catch (...) {
34791       {
34792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34793       };
34794     }
34795   }
34796
34797 }
34798
34799
34800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34801   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34802   Dali::Degree *arg2 = 0 ;
34803   Dali::Vector3 *arg3 = 0 ;
34804
34805   arg1 = (Dali::Actor *)jarg1;
34806   arg2 = (Dali::Degree *)jarg2;
34807   if (!arg2) {
34808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34809     return ;
34810   }
34811   arg3 = (Dali::Vector3 *)jarg3;
34812   if (!arg3) {
34813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34814     return ;
34815   }
34816   {
34817     try {
34818       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34819     } catch (std::out_of_range& e) {
34820       {
34821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34822       };
34823     } catch (std::exception& e) {
34824       {
34825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34826       };
34827     } catch (Dali::DaliException e) {
34828       {
34829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34830       };
34831     } catch (...) {
34832       {
34833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34834       };
34835     }
34836   }
34837
34838 }
34839
34840
34841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34842   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34843   Dali::Radian *arg2 = 0 ;
34844   Dali::Vector3 *arg3 = 0 ;
34845
34846   arg1 = (Dali::Actor *)jarg1;
34847   arg2 = (Dali::Radian *)jarg2;
34848   if (!arg2) {
34849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34850     return ;
34851   }
34852   arg3 = (Dali::Vector3 *)jarg3;
34853   if (!arg3) {
34854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34855     return ;
34856   }
34857   {
34858     try {
34859       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34860     } catch (std::out_of_range& e) {
34861       {
34862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34863       };
34864     } catch (std::exception& e) {
34865       {
34866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34867       };
34868     } catch (Dali::DaliException e) {
34869       {
34870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34871       };
34872     } catch (...) {
34873       {
34874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34875       };
34876     }
34877   }
34878
34879 }
34880
34881
34882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
34883   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34884   Dali::Quaternion *arg2 = 0 ;
34885
34886   arg1 = (Dali::Actor *)jarg1;
34887   arg2 = (Dali::Quaternion *)jarg2;
34888   if (!arg2) {
34889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34890     return ;
34891   }
34892   {
34893     try {
34894       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
34895     } catch (std::out_of_range& e) {
34896       {
34897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34898       };
34899     } catch (std::exception& e) {
34900       {
34901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34902       };
34903     } catch (Dali::DaliException e) {
34904       {
34905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34906       };
34907     } catch (...) {
34908       {
34909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34910       };
34911     }
34912   }
34913
34914 }
34915
34916
34917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
34918   void * jresult ;
34919   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34920   Dali::Quaternion result;
34921
34922   arg1 = (Dali::Actor *)jarg1;
34923   {
34924     try {
34925       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
34926     } catch (std::out_of_range& e) {
34927       {
34928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34929       };
34930     } catch (std::exception& e) {
34931       {
34932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34933       };
34934     } catch (Dali::DaliException e) {
34935       {
34936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34937       };
34938     } catch (...) {
34939       {
34940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34941       };
34942     }
34943   }
34944
34945   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
34946   return jresult;
34947 }
34948
34949
34950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
34951   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34952   bool arg2 ;
34953
34954   arg1 = (Dali::Actor *)jarg1;
34955   arg2 = jarg2 ? true : false;
34956   {
34957     try {
34958       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
34959     } catch (std::out_of_range& e) {
34960       {
34961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34962       };
34963     } catch (std::exception& e) {
34964       {
34965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34966       };
34967     } catch (Dali::DaliException e) {
34968       {
34969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34970       };
34971     } catch (...) {
34972       {
34973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34974       };
34975     }
34976   }
34977
34978 }
34979
34980
34981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
34982   unsigned int jresult ;
34983   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34984   bool result;
34985
34986   arg1 = (Dali::Actor *)jarg1;
34987   {
34988     try {
34989       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
34990     } catch (std::out_of_range& e) {
34991       {
34992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34993       };
34994     } catch (std::exception& e) {
34995       {
34996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34997       };
34998     } catch (Dali::DaliException e) {
34999       {
35000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35001       };
35002     } catch (...) {
35003       {
35004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35005       };
35006     }
35007   }
35008
35009   jresult = result;
35010   return jresult;
35011 }
35012
35013
35014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35015   void * jresult ;
35016   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35017   Dali::Quaternion result;
35018
35019   arg1 = (Dali::Actor *)jarg1;
35020   {
35021     try {
35022       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
35023     } catch (std::out_of_range& e) {
35024       {
35025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35026       };
35027     } catch (std::exception& e) {
35028       {
35029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35030       };
35031     } catch (Dali::DaliException e) {
35032       {
35033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35034       };
35035     } catch (...) {
35036       {
35037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35038       };
35039     }
35040   }
35041
35042   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35043   return jresult;
35044 }
35045
35046
35047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35048   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35049   float arg2 ;
35050
35051   arg1 = (Dali::Actor *)jarg1;
35052   arg2 = (float)jarg2;
35053   {
35054     try {
35055       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
35056     } catch (std::out_of_range& e) {
35057       {
35058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35059       };
35060     } catch (std::exception& e) {
35061       {
35062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35063       };
35064     } catch (Dali::DaliException e) {
35065       {
35066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35067       };
35068     } catch (...) {
35069       {
35070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35071       };
35072     }
35073   }
35074
35075 }
35076
35077
35078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35079   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35080   float arg2 ;
35081   float arg3 ;
35082   float arg4 ;
35083
35084   arg1 = (Dali::Actor *)jarg1;
35085   arg2 = (float)jarg2;
35086   arg3 = (float)jarg3;
35087   arg4 = (float)jarg4;
35088   {
35089     try {
35090       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
35091     } catch (std::out_of_range& e) {
35092       {
35093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35094       };
35095     } catch (std::exception& e) {
35096       {
35097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35098       };
35099     } catch (Dali::DaliException e) {
35100       {
35101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35102       };
35103     } catch (...) {
35104       {
35105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35106       };
35107     }
35108   }
35109
35110 }
35111
35112
35113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35114   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35115   Dali::Vector3 *arg2 = 0 ;
35116
35117   arg1 = (Dali::Actor *)jarg1;
35118   arg2 = (Dali::Vector3 *)jarg2;
35119   if (!arg2) {
35120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35121     return ;
35122   }
35123   {
35124     try {
35125       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
35126     } catch (std::out_of_range& e) {
35127       {
35128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35129       };
35130     } catch (std::exception& e) {
35131       {
35132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35133       };
35134     } catch (Dali::DaliException e) {
35135       {
35136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35137       };
35138     } catch (...) {
35139       {
35140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35141       };
35142     }
35143   }
35144
35145 }
35146
35147
35148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35149   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35150   Dali::Vector3 *arg2 = 0 ;
35151
35152   arg1 = (Dali::Actor *)jarg1;
35153   arg2 = (Dali::Vector3 *)jarg2;
35154   if (!arg2) {
35155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35156     return ;
35157   }
35158   {
35159     try {
35160       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35161     } catch (std::out_of_range& e) {
35162       {
35163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35164       };
35165     } catch (std::exception& e) {
35166       {
35167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35168       };
35169     } catch (Dali::DaliException e) {
35170       {
35171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35172       };
35173     } catch (...) {
35174       {
35175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35176       };
35177     }
35178   }
35179
35180 }
35181
35182
35183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35184   void * jresult ;
35185   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35186   Dali::Vector3 result;
35187
35188   arg1 = (Dali::Actor *)jarg1;
35189   {
35190     try {
35191       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
35192     } catch (std::out_of_range& e) {
35193       {
35194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35195       };
35196     } catch (std::exception& e) {
35197       {
35198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35199       };
35200     } catch (Dali::DaliException e) {
35201       {
35202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35203       };
35204     } catch (...) {
35205       {
35206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35207       };
35208     }
35209   }
35210
35211   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35212   return jresult;
35213 }
35214
35215
35216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35217   void * jresult ;
35218   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35219   Dali::Vector3 result;
35220
35221   arg1 = (Dali::Actor *)jarg1;
35222   {
35223     try {
35224       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
35225     } catch (std::out_of_range& e) {
35226       {
35227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35228       };
35229     } catch (std::exception& e) {
35230       {
35231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35232       };
35233     } catch (Dali::DaliException e) {
35234       {
35235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35236       };
35237     } catch (...) {
35238       {
35239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35240       };
35241     }
35242   }
35243
35244   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35245   return jresult;
35246 }
35247
35248
35249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35250   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35251   bool arg2 ;
35252
35253   arg1 = (Dali::Actor *)jarg1;
35254   arg2 = jarg2 ? true : false;
35255   {
35256     try {
35257       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
35258     } catch (std::out_of_range& e) {
35259       {
35260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35261       };
35262     } catch (std::exception& e) {
35263       {
35264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35265       };
35266     } catch (Dali::DaliException e) {
35267       {
35268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35269       };
35270     } catch (...) {
35271       {
35272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35273       };
35274     }
35275   }
35276
35277 }
35278
35279
35280 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35281   unsigned int jresult ;
35282   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35283   bool result;
35284
35285   arg1 = (Dali::Actor *)jarg1;
35286   {
35287     try {
35288       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
35289     } catch (std::out_of_range& e) {
35290       {
35291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35292       };
35293     } catch (std::exception& e) {
35294       {
35295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35296       };
35297     } catch (Dali::DaliException e) {
35298       {
35299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35300       };
35301     } catch (...) {
35302       {
35303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35304       };
35305     }
35306   }
35307
35308   jresult = result;
35309   return jresult;
35310 }
35311
35312
35313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35314   void * jresult ;
35315   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35316   Dali::Matrix result;
35317
35318   arg1 = (Dali::Actor *)jarg1;
35319   {
35320     try {
35321       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
35322     } catch (std::out_of_range& e) {
35323       {
35324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35325       };
35326     } catch (std::exception& e) {
35327       {
35328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35329       };
35330     } catch (Dali::DaliException e) {
35331       {
35332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35333       };
35334     } catch (...) {
35335       {
35336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35337       };
35338     }
35339   }
35340
35341   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35342   return jresult;
35343 }
35344
35345
35346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35347   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35348   bool arg2 ;
35349
35350   arg1 = (Dali::Actor *)jarg1;
35351   arg2 = jarg2 ? true : false;
35352   {
35353     try {
35354       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
35355     } catch (std::out_of_range& e) {
35356       {
35357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35358       };
35359     } catch (std::exception& e) {
35360       {
35361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35362       };
35363     } catch (Dali::DaliException e) {
35364       {
35365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35366       };
35367     } catch (...) {
35368       {
35369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35370       };
35371     }
35372   }
35373
35374 }
35375
35376
35377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35378   unsigned int jresult ;
35379   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35380   bool result;
35381
35382   arg1 = (Dali::Actor *)jarg1;
35383   {
35384     try {
35385       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
35386     } catch (std::out_of_range& e) {
35387       {
35388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35389       };
35390     } catch (std::exception& e) {
35391       {
35392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35393       };
35394     } catch (Dali::DaliException e) {
35395       {
35396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35397       };
35398     } catch (...) {
35399       {
35400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35401       };
35402     }
35403   }
35404
35405   jresult = result;
35406   return jresult;
35407 }
35408
35409
35410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35411   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35412   float arg2 ;
35413
35414   arg1 = (Dali::Actor *)jarg1;
35415   arg2 = (float)jarg2;
35416   {
35417     try {
35418       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
35419     } catch (std::out_of_range& e) {
35420       {
35421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35422       };
35423     } catch (std::exception& e) {
35424       {
35425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35426       };
35427     } catch (Dali::DaliException e) {
35428       {
35429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35430       };
35431     } catch (...) {
35432       {
35433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35434       };
35435     }
35436   }
35437
35438 }
35439
35440
35441 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35442   float jresult ;
35443   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35444   float result;
35445
35446   arg1 = (Dali::Actor *)jarg1;
35447   {
35448     try {
35449       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
35450     } catch (std::out_of_range& e) {
35451       {
35452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35453       };
35454     } catch (std::exception& e) {
35455       {
35456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35457       };
35458     } catch (Dali::DaliException e) {
35459       {
35460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35461       };
35462     } catch (...) {
35463       {
35464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35465       };
35466     }
35467   }
35468
35469   jresult = result;
35470   return jresult;
35471 }
35472
35473
35474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35475   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35476   Dali::Vector4 *arg2 = 0 ;
35477
35478   arg1 = (Dali::Actor *)jarg1;
35479   arg2 = (Dali::Vector4 *)jarg2;
35480   if (!arg2) {
35481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35482     return ;
35483   }
35484   {
35485     try {
35486       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
35487     } catch (std::out_of_range& e) {
35488       {
35489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35490       };
35491     } catch (std::exception& e) {
35492       {
35493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35494       };
35495     } catch (Dali::DaliException e) {
35496       {
35497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35498       };
35499     } catch (...) {
35500       {
35501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35502       };
35503     }
35504   }
35505
35506 }
35507
35508
35509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35510   void * jresult ;
35511   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35512   Dali::Vector4 result;
35513
35514   arg1 = (Dali::Actor *)jarg1;
35515   {
35516     try {
35517       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
35518     } catch (std::out_of_range& e) {
35519       {
35520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35521       };
35522     } catch (std::exception& e) {
35523       {
35524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35525       };
35526     } catch (Dali::DaliException e) {
35527       {
35528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35529       };
35530     } catch (...) {
35531       {
35532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35533       };
35534     }
35535   }
35536
35537   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35538   return jresult;
35539 }
35540
35541
35542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35543   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35544   Dali::ColorMode arg2 ;
35545
35546   arg1 = (Dali::Actor *)jarg1;
35547   arg2 = (Dali::ColorMode)jarg2;
35548   {
35549     try {
35550       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
35551     } catch (std::out_of_range& e) {
35552       {
35553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35554       };
35555     } catch (std::exception& e) {
35556       {
35557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35558       };
35559     } catch (Dali::DaliException e) {
35560       {
35561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35562       };
35563     } catch (...) {
35564       {
35565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35566       };
35567     }
35568   }
35569
35570 }
35571
35572
35573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35574   int jresult ;
35575   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35576   Dali::ColorMode result;
35577
35578   arg1 = (Dali::Actor *)jarg1;
35579   {
35580     try {
35581       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
35582     } catch (std::out_of_range& e) {
35583       {
35584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35585       };
35586     } catch (std::exception& e) {
35587       {
35588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35589       };
35590     } catch (Dali::DaliException e) {
35591       {
35592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35593       };
35594     } catch (...) {
35595       {
35596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35597       };
35598     }
35599   }
35600
35601   jresult = (int)result;
35602   return jresult;
35603 }
35604
35605
35606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35607   void * jresult ;
35608   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35609   Dali::Vector4 result;
35610
35611   arg1 = (Dali::Actor *)jarg1;
35612   {
35613     try {
35614       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
35615     } catch (std::out_of_range& e) {
35616       {
35617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35618       };
35619     } catch (std::exception& e) {
35620       {
35621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35622       };
35623     } catch (Dali::DaliException e) {
35624       {
35625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35626       };
35627     } catch (...) {
35628       {
35629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35630       };
35631     }
35632   }
35633
35634   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35635   return jresult;
35636 }
35637
35638
35639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35640   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35641   Dali::DrawMode::Type arg2 ;
35642
35643   arg1 = (Dali::Actor *)jarg1;
35644   arg2 = (Dali::DrawMode::Type)jarg2;
35645   {
35646     try {
35647       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
35648     } catch (std::out_of_range& e) {
35649       {
35650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35651       };
35652     } catch (std::exception& e) {
35653       {
35654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35655       };
35656     } catch (Dali::DaliException e) {
35657       {
35658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35659       };
35660     } catch (...) {
35661       {
35662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35663       };
35664     }
35665   }
35666
35667 }
35668
35669
35670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35671   int jresult ;
35672   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35673   Dali::DrawMode::Type result;
35674
35675   arg1 = (Dali::Actor *)jarg1;
35676   {
35677     try {
35678       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
35679     } catch (std::out_of_range& e) {
35680       {
35681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35682       };
35683     } catch (std::exception& e) {
35684       {
35685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35686       };
35687     } catch (Dali::DaliException e) {
35688       {
35689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35690       };
35691     } catch (...) {
35692       {
35693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35694       };
35695     }
35696   }
35697
35698   jresult = (int)result;
35699   return jresult;
35700 }
35701
35702
35703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35704   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35705   bool arg2 ;
35706
35707   arg1 = (Dali::Actor *)jarg1;
35708   arg2 = jarg2 ? true : false;
35709   {
35710     try {
35711       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
35712     } catch (std::out_of_range& e) {
35713       {
35714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35715       };
35716     } catch (std::exception& e) {
35717       {
35718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35719       };
35720     } catch (Dali::DaliException e) {
35721       {
35722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35723       };
35724     } catch (...) {
35725       {
35726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35727       };
35728     }
35729   }
35730
35731 }
35732
35733
35734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35735   unsigned int jresult ;
35736   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35737   bool result;
35738
35739   arg1 = (Dali::Actor *)jarg1;
35740   {
35741     try {
35742       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
35743     } catch (std::out_of_range& e) {
35744       {
35745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35746       };
35747     } catch (std::exception& e) {
35748       {
35749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35750       };
35751     } catch (Dali::DaliException e) {
35752       {
35753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35754       };
35755     } catch (...) {
35756       {
35757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35758       };
35759     }
35760   }
35761
35762   jresult = result;
35763   return jresult;
35764 }
35765
35766
35767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35768   unsigned int jresult ;
35769   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35770   float *arg2 = 0 ;
35771   float *arg3 = 0 ;
35772   float arg4 ;
35773   float arg5 ;
35774   bool result;
35775
35776   arg1 = (Dali::Actor *)jarg1;
35777   arg2 = (float *)jarg2;
35778   arg3 = (float *)jarg3;
35779   arg4 = (float)jarg4;
35780   arg5 = (float)jarg5;
35781   {
35782     try {
35783       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35784     } catch (std::out_of_range& e) {
35785       {
35786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35787       };
35788     } catch (std::exception& e) {
35789       {
35790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35791       };
35792     } catch (Dali::DaliException e) {
35793       {
35794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35795       };
35796     } catch (...) {
35797       {
35798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35799       };
35800     }
35801   }
35802
35803   jresult = result;
35804   return jresult;
35805 }
35806
35807
35808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
35809   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35810   bool arg2 ;
35811
35812   arg1 = (Dali::Actor *)jarg1;
35813   arg2 = jarg2 ? true : false;
35814   {
35815     try {
35816       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
35817     } catch (std::out_of_range& e) {
35818       {
35819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35820       };
35821     } catch (std::exception& e) {
35822       {
35823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35824       };
35825     } catch (Dali::DaliException e) {
35826       {
35827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35828       };
35829     } catch (...) {
35830       {
35831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35832       };
35833     }
35834   }
35835
35836 }
35837
35838
35839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
35840   unsigned int jresult ;
35841   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35842   bool result;
35843
35844   arg1 = (Dali::Actor *)jarg1;
35845   {
35846     try {
35847       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
35848     } catch (std::out_of_range& e) {
35849       {
35850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35851       };
35852     } catch (std::exception& e) {
35853       {
35854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35855       };
35856     } catch (Dali::DaliException e) {
35857       {
35858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35859       };
35860     } catch (...) {
35861       {
35862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35863       };
35864     }
35865   }
35866
35867   jresult = result;
35868   return jresult;
35869 }
35870
35871
35872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
35873   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35874   bool arg2 ;
35875
35876   arg1 = (Dali::Actor *)jarg1;
35877   arg2 = jarg2 ? true : false;
35878   {
35879     try {
35880       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
35881     } catch (std::out_of_range& e) {
35882       {
35883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35884       };
35885     } catch (std::exception& e) {
35886       {
35887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35888       };
35889     } catch (Dali::DaliException e) {
35890       {
35891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35892       };
35893     } catch (...) {
35894       {
35895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35896       };
35897     }
35898   }
35899
35900 }
35901
35902
35903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
35904   unsigned int jresult ;
35905   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35906   bool result;
35907
35908   arg1 = (Dali::Actor *)jarg1;
35909   {
35910     try {
35911       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
35912     } catch (std::out_of_range& e) {
35913       {
35914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35915       };
35916     } catch (std::exception& e) {
35917       {
35918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35919       };
35920     } catch (Dali::DaliException e) {
35921       {
35922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35923       };
35924     } catch (...) {
35925       {
35926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35927       };
35928     }
35929   }
35930
35931   jresult = result;
35932   return jresult;
35933 }
35934
35935
35936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
35937   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35938   Dali::ResizePolicy::Type arg2 ;
35939   Dali::Dimension::Type arg3 ;
35940
35941   arg1 = (Dali::Actor *)jarg1;
35942   arg2 = (Dali::ResizePolicy::Type)jarg2;
35943   arg3 = (Dali::Dimension::Type)jarg3;
35944   {
35945     try {
35946       (arg1)->SetResizePolicy(arg2,arg3);
35947     } catch (std::out_of_range& e) {
35948       {
35949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35950       };
35951     } catch (std::exception& e) {
35952       {
35953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35954       };
35955     } catch (Dali::DaliException e) {
35956       {
35957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35958       };
35959     } catch (...) {
35960       {
35961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35962       };
35963     }
35964   }
35965
35966 }
35967
35968
35969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
35970   int jresult ;
35971   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35972   Dali::Dimension::Type arg2 ;
35973   Dali::ResizePolicy::Type result;
35974
35975   arg1 = (Dali::Actor *)jarg1;
35976   arg2 = (Dali::Dimension::Type)jarg2;
35977   {
35978     try {
35979       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
35980     } catch (std::out_of_range& e) {
35981       {
35982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35983       };
35984     } catch (std::exception& e) {
35985       {
35986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35987       };
35988     } catch (Dali::DaliException e) {
35989       {
35990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35991       };
35992     } catch (...) {
35993       {
35994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35995       };
35996     }
35997   }
35998
35999   jresult = (int)result;
36000   return jresult;
36001 }
36002
36003
36004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36005   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36006   Dali::SizeScalePolicy::Type arg2 ;
36007
36008   arg1 = (Dali::Actor *)jarg1;
36009   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36010   {
36011     try {
36012       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
36013     } catch (std::out_of_range& e) {
36014       {
36015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36016       };
36017     } catch (std::exception& e) {
36018       {
36019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36020       };
36021     } catch (Dali::DaliException e) {
36022       {
36023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36024       };
36025     } catch (...) {
36026       {
36027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36028       };
36029     }
36030   }
36031
36032 }
36033
36034
36035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36036   int jresult ;
36037   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36038   Dali::SizeScalePolicy::Type result;
36039
36040   arg1 = (Dali::Actor *)jarg1;
36041   {
36042     try {
36043       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
36044     } catch (std::out_of_range& e) {
36045       {
36046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36047       };
36048     } catch (std::exception& e) {
36049       {
36050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36051       };
36052     } catch (Dali::DaliException e) {
36053       {
36054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36055       };
36056     } catch (...) {
36057       {
36058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36059       };
36060     }
36061   }
36062
36063   jresult = (int)result;
36064   return jresult;
36065 }
36066
36067
36068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36069   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36070   Dali::Vector3 *arg2 = 0 ;
36071
36072   arg1 = (Dali::Actor *)jarg1;
36073   arg2 = (Dali::Vector3 *)jarg2;
36074   if (!arg2) {
36075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36076     return ;
36077   }
36078   {
36079     try {
36080       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
36081     } catch (std::out_of_range& e) {
36082       {
36083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36084       };
36085     } catch (std::exception& e) {
36086       {
36087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36088       };
36089     } catch (Dali::DaliException e) {
36090       {
36091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36092       };
36093     } catch (...) {
36094       {
36095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36096       };
36097     }
36098   }
36099
36100 }
36101
36102
36103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36104   void * jresult ;
36105   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36106   Dali::Vector3 result;
36107
36108   arg1 = (Dali::Actor *)jarg1;
36109   {
36110     try {
36111       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
36112     } catch (std::out_of_range& e) {
36113       {
36114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36115       };
36116     } catch (std::exception& e) {
36117       {
36118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36119       };
36120     } catch (Dali::DaliException e) {
36121       {
36122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36123       };
36124     } catch (...) {
36125       {
36126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36127       };
36128     }
36129   }
36130
36131   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36132   return jresult;
36133 }
36134
36135
36136 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36137   float jresult ;
36138   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36139   float arg2 ;
36140   float result;
36141
36142   arg1 = (Dali::Actor *)jarg1;
36143   arg2 = (float)jarg2;
36144   {
36145     try {
36146       result = (float)(arg1)->GetHeightForWidth(arg2);
36147     } catch (std::out_of_range& e) {
36148       {
36149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36150       };
36151     } catch (std::exception& e) {
36152       {
36153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36154       };
36155     } catch (Dali::DaliException e) {
36156       {
36157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36158       };
36159     } catch (...) {
36160       {
36161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36162       };
36163     }
36164   }
36165
36166   jresult = result;
36167   return jresult;
36168 }
36169
36170
36171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36172   float jresult ;
36173   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36174   float arg2 ;
36175   float result;
36176
36177   arg1 = (Dali::Actor *)jarg1;
36178   arg2 = (float)jarg2;
36179   {
36180     try {
36181       result = (float)(arg1)->GetWidthForHeight(arg2);
36182     } catch (std::out_of_range& e) {
36183       {
36184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36185       };
36186     } catch (std::exception& e) {
36187       {
36188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36189       };
36190     } catch (Dali::DaliException e) {
36191       {
36192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36193       };
36194     } catch (...) {
36195       {
36196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36197       };
36198     }
36199   }
36200
36201   jresult = result;
36202   return jresult;
36203 }
36204
36205
36206 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36207   float jresult ;
36208   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36209   Dali::Dimension::Type arg2 ;
36210   float result;
36211
36212   arg1 = (Dali::Actor *)jarg1;
36213   arg2 = (Dali::Dimension::Type)jarg2;
36214   {
36215     try {
36216       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36217     } catch (std::out_of_range& e) {
36218       {
36219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36220       };
36221     } catch (std::exception& e) {
36222       {
36223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36224       };
36225     } catch (Dali::DaliException e) {
36226       {
36227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36228       };
36229     } catch (...) {
36230       {
36231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36232       };
36233     }
36234   }
36235
36236   jresult = result;
36237   return jresult;
36238 }
36239
36240
36241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36242   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36243   Dali::Padding *arg2 = 0 ;
36244
36245   arg1 = (Dali::Actor *)jarg1;
36246   arg2 = (Dali::Padding *)jarg2;
36247   if (!arg2) {
36248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36249     return ;
36250   }
36251   {
36252     try {
36253       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
36254     } catch (std::out_of_range& e) {
36255       {
36256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36257       };
36258     } catch (std::exception& e) {
36259       {
36260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36261       };
36262     } catch (Dali::DaliException e) {
36263       {
36264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36265       };
36266     } catch (...) {
36267       {
36268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36269       };
36270     }
36271   }
36272
36273 }
36274
36275
36276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36277   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36278   Dali::Padding *arg2 = 0 ;
36279
36280   arg1 = (Dali::Actor *)jarg1;
36281   arg2 = (Dali::Padding *)jarg2;
36282   if (!arg2) {
36283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36284     return ;
36285   }
36286   {
36287     try {
36288       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
36289     } catch (std::out_of_range& e) {
36290       {
36291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36292       };
36293     } catch (std::exception& e) {
36294       {
36295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36296       };
36297     } catch (Dali::DaliException e) {
36298       {
36299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36300       };
36301     } catch (...) {
36302       {
36303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36304       };
36305     }
36306   }
36307
36308 }
36309
36310
36311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36312   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36313   Dali::Vector2 *arg2 = 0 ;
36314
36315   arg1 = (Dali::Actor *)jarg1;
36316   arg2 = (Dali::Vector2 *)jarg2;
36317   if (!arg2) {
36318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36319     return ;
36320   }
36321   {
36322     try {
36323       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36324     } catch (std::out_of_range& e) {
36325       {
36326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36327       };
36328     } catch (std::exception& e) {
36329       {
36330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36331       };
36332     } catch (Dali::DaliException e) {
36333       {
36334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36335       };
36336     } catch (...) {
36337       {
36338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36339       };
36340     }
36341   }
36342
36343 }
36344
36345
36346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36347   void * jresult ;
36348   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36349   Dali::Vector2 result;
36350
36351   arg1 = (Dali::Actor *)jarg1;
36352   {
36353     try {
36354       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
36355     } catch (std::out_of_range& e) {
36356       {
36357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36358       };
36359     } catch (std::exception& e) {
36360       {
36361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36362       };
36363     } catch (Dali::DaliException e) {
36364       {
36365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36366       };
36367     } catch (...) {
36368       {
36369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36370       };
36371     }
36372   }
36373
36374   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36375   return jresult;
36376 }
36377
36378
36379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36380   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36381   Dali::Vector2 *arg2 = 0 ;
36382
36383   arg1 = (Dali::Actor *)jarg1;
36384   arg2 = (Dali::Vector2 *)jarg2;
36385   if (!arg2) {
36386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36387     return ;
36388   }
36389   {
36390     try {
36391       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36392     } catch (std::out_of_range& e) {
36393       {
36394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36395       };
36396     } catch (std::exception& e) {
36397       {
36398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36399       };
36400     } catch (Dali::DaliException e) {
36401       {
36402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36403       };
36404     } catch (...) {
36405       {
36406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36407       };
36408     }
36409   }
36410
36411 }
36412
36413
36414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36415   void * jresult ;
36416   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36417   Dali::Vector2 result;
36418
36419   arg1 = (Dali::Actor *)jarg1;
36420   {
36421     try {
36422       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
36423     } catch (std::out_of_range& e) {
36424       {
36425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36426       };
36427     } catch (std::exception& e) {
36428       {
36429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36430       };
36431     } catch (Dali::DaliException e) {
36432       {
36433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36434       };
36435     } catch (...) {
36436       {
36437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36438       };
36439     }
36440   }
36441
36442   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36443   return jresult;
36444 }
36445
36446
36447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36448   int jresult ;
36449   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36450   int result;
36451
36452   arg1 = (Dali::Actor *)jarg1;
36453   {
36454     try {
36455       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
36456       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36457     } catch (std::out_of_range& e) {
36458       {
36459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36460       };
36461     } catch (std::exception& e) {
36462       {
36463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36464       };
36465     } catch (Dali::DaliException e) {
36466       {
36467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36468       };
36469     } catch (...) {
36470       {
36471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36472       };
36473     }
36474   }
36475
36476   jresult = result;
36477   return jresult;
36478 }
36479
36480
36481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36482   unsigned int jresult ;
36483   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36484   Dali::Renderer *arg2 = 0 ;
36485   unsigned int result;
36486
36487   arg1 = (Dali::Actor *)jarg1;
36488   arg2 = (Dali::Renderer *)jarg2;
36489   if (!arg2) {
36490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36491     return 0;
36492   }
36493   {
36494     try {
36495       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36496     } catch (std::out_of_range& e) {
36497       {
36498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36499       };
36500     } catch (std::exception& e) {
36501       {
36502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36503       };
36504     } catch (Dali::DaliException e) {
36505       {
36506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36507       };
36508     } catch (...) {
36509       {
36510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36511       };
36512     }
36513   }
36514
36515   jresult = result;
36516   return jresult;
36517 }
36518
36519
36520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36521   unsigned int jresult ;
36522   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36523   unsigned int result;
36524
36525   arg1 = (Dali::Actor *)jarg1;
36526   {
36527     try {
36528       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36529     } catch (std::out_of_range& e) {
36530       {
36531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36532       };
36533     } catch (std::exception& e) {
36534       {
36535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36536       };
36537     } catch (Dali::DaliException e) {
36538       {
36539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36540       };
36541     } catch (...) {
36542       {
36543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36544       };
36545     }
36546   }
36547
36548   jresult = result;
36549   return jresult;
36550 }
36551
36552
36553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36554   void * jresult ;
36555   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36556   unsigned int arg2 ;
36557   Dali::Renderer result;
36558
36559   arg1 = (Dali::Actor *)jarg1;
36560   arg2 = (unsigned int)jarg2;
36561   {
36562     try {
36563       result = (arg1)->GetRendererAt(arg2);
36564     } catch (std::out_of_range& e) {
36565       {
36566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36567       };
36568     } catch (std::exception& e) {
36569       {
36570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36571       };
36572     } catch (Dali::DaliException e) {
36573       {
36574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36575       };
36576     } catch (...) {
36577       {
36578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36579       };
36580     }
36581   }
36582
36583   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36584   return jresult;
36585 }
36586
36587
36588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36589   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36590   Dali::Renderer *arg2 = 0 ;
36591
36592   arg1 = (Dali::Actor *)jarg1;
36593   arg2 = (Dali::Renderer *)jarg2;
36594   if (!arg2) {
36595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36596     return ;
36597   }
36598   {
36599     try {
36600       (arg1)->RemoveRenderer(*arg2);
36601     } catch (std::out_of_range& e) {
36602       {
36603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36604       };
36605     } catch (std::exception& e) {
36606       {
36607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36608       };
36609     } catch (Dali::DaliException e) {
36610       {
36611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36612       };
36613     } catch (...) {
36614       {
36615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36616       };
36617     }
36618   }
36619
36620 }
36621
36622
36623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36624   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36625   unsigned int arg2 ;
36626
36627   arg1 = (Dali::Actor *)jarg1;
36628   arg2 = (unsigned int)jarg2;
36629   {
36630     try {
36631       (arg1)->RemoveRenderer(arg2);
36632     } catch (std::out_of_range& e) {
36633       {
36634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36635       };
36636     } catch (std::exception& e) {
36637       {
36638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36639       };
36640     } catch (Dali::DaliException e) {
36641       {
36642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36643       };
36644     } catch (...) {
36645       {
36646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36647       };
36648     }
36649   }
36650
36651 }
36652
36653
36654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36655   void * jresult ;
36656   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36657   Dali::Actor::TouchEventSignalType *result = 0 ;
36658
36659   arg1 = (Dali::Actor *)jarg1;
36660   {
36661     try {
36662       result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchSignal();
36663     } catch (std::out_of_range& e) {
36664       {
36665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36666       };
36667     } catch (std::exception& e) {
36668       {
36669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36670       };
36671     } catch (Dali::DaliException e) {
36672       {
36673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36674       };
36675     } catch (...) {
36676       {
36677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36678       };
36679     }
36680   }
36681
36682   jresult = (void *)result;
36683   return jresult;
36684 }
36685
36686
36687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36688   void * jresult ;
36689   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36690   Dali::Actor::HoverSignalType *result = 0 ;
36691
36692   arg1 = (Dali::Actor *)jarg1;
36693   {
36694     try {
36695       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36696     } catch (std::out_of_range& e) {
36697       {
36698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36699       };
36700     } catch (std::exception& e) {
36701       {
36702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36703       };
36704     } catch (Dali::DaliException e) {
36705       {
36706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36707       };
36708     } catch (...) {
36709       {
36710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36711       };
36712     }
36713   }
36714
36715   jresult = (void *)result;
36716   return jresult;
36717 }
36718
36719
36720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36721   void * jresult ;
36722   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36723   Dali::Actor::WheelEventSignalType *result = 0 ;
36724
36725   arg1 = (Dali::Actor *)jarg1;
36726   {
36727     try {
36728       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36729     } catch (std::out_of_range& e) {
36730       {
36731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36732       };
36733     } catch (std::exception& e) {
36734       {
36735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36736       };
36737     } catch (Dali::DaliException e) {
36738       {
36739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36740       };
36741     } catch (...) {
36742       {
36743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36744       };
36745     }
36746   }
36747
36748   jresult = (void *)result;
36749   return jresult;
36750 }
36751
36752
36753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
36754   void * jresult ;
36755   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36756   Dali::Actor::OnSceneSignalType *result = 0 ;
36757
36758   arg1 = (Dali::Actor *)jarg1;
36759   {
36760     try {
36761       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
36762     } catch (std::out_of_range& e) {
36763       {
36764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36765       };
36766     } catch (std::exception& e) {
36767       {
36768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36769       };
36770     } catch (Dali::DaliException e) {
36771       {
36772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36773       };
36774     } catch (...) {
36775       {
36776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36777       };
36778     }
36779   }
36780
36781   jresult = (void *)result;
36782   return jresult;
36783 }
36784
36785
36786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
36787   void * jresult ;
36788   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36789   Dali::Actor::OffSceneSignalType *result = 0 ;
36790
36791   arg1 = (Dali::Actor *)jarg1;
36792   {
36793     try {
36794       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
36795     } catch (std::out_of_range& e) {
36796       {
36797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36798       };
36799     } catch (std::exception& e) {
36800       {
36801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36802       };
36803     } catch (Dali::DaliException e) {
36804       {
36805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36806       };
36807     } catch (...) {
36808       {
36809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36810       };
36811     }
36812   }
36813
36814   jresult = (void *)result;
36815   return jresult;
36816 }
36817
36818
36819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
36820   void * jresult ;
36821   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36822   Dali::Actor::OnRelayoutSignalType *result = 0 ;
36823
36824   arg1 = (Dali::Actor *)jarg1;
36825   {
36826     try {
36827       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
36828     } catch (std::out_of_range& e) {
36829       {
36830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36831       };
36832     } catch (std::exception& e) {
36833       {
36834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36835       };
36836     } catch (Dali::DaliException e) {
36837       {
36838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36839       };
36840     } catch (...) {
36841       {
36842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36843       };
36844     }
36845   }
36846
36847   jresult = (void *)result;
36848   return jresult;
36849 }
36850
36851
36852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
36853   Dali::Actor *arg1 = 0 ;
36854
36855   arg1 = (Dali::Actor *)jarg1;
36856   if (!arg1) {
36857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36858     return ;
36859   }
36860   {
36861     try {
36862       Dali::UnparentAndReset(*arg1);
36863     } catch (std::out_of_range& e) {
36864       {
36865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36866       };
36867     } catch (std::exception& e) {
36868       {
36869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36870       };
36871     } catch (Dali::DaliException e) {
36872       {
36873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36874       };
36875     } catch (...) {
36876       {
36877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36878       };
36879     }
36880   }
36881
36882 }
36883
36884
36885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
36886   int jresult ;
36887   int result;
36888
36889   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
36890   jresult = (int)result;
36891   return jresult;
36892 }
36893
36894
36895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
36896   int jresult ;
36897   int result;
36898
36899   result = (int)Dali::Layer::Property::CLIPPING_BOX;
36900   jresult = (int)result;
36901   return jresult;
36902 }
36903
36904
36905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
36906   int jresult ;
36907   int result;
36908
36909   result = (int)Dali::Layer::Property::BEHAVIOR;
36910   jresult = (int)result;
36911   return jresult;
36912 }
36913
36914
36915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
36916   void * jresult ;
36917   Dali::Layer::Property *result = 0 ;
36918
36919   {
36920     try {
36921       result = (Dali::Layer::Property *)new Dali::Layer::Property();
36922     } catch (std::out_of_range& e) {
36923       {
36924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36925       };
36926     } catch (std::exception& e) {
36927       {
36928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36929       };
36930     } catch (Dali::DaliException e) {
36931       {
36932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36933       };
36934     } catch (...) {
36935       {
36936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36937       };
36938     }
36939   }
36940
36941   jresult = (void *)result;
36942   return jresult;
36943 }
36944
36945
36946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
36947   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
36948
36949   arg1 = (Dali::Layer::Property *)jarg1;
36950   {
36951     try {
36952       delete arg1;
36953     } catch (std::out_of_range& e) {
36954       {
36955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36956       };
36957     } catch (std::exception& e) {
36958       {
36959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36960       };
36961     } catch (Dali::DaliException e) {
36962       {
36963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36964       };
36965     } catch (...) {
36966       {
36967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36968       };
36969     }
36970   }
36971
36972 }
36973
36974
36975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
36976   void * jresult ;
36977   Dali::Layer *result = 0 ;
36978
36979   {
36980     try {
36981       result = (Dali::Layer *)new Dali::Layer();
36982     } catch (std::out_of_range& e) {
36983       {
36984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36985       };
36986     } catch (std::exception& e) {
36987       {
36988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36989       };
36990     } catch (Dali::DaliException e) {
36991       {
36992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36993       };
36994     } catch (...) {
36995       {
36996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36997       };
36998     }
36999   }
37000
37001   jresult = (void *)result;
37002   return jresult;
37003 }
37004
37005
37006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37007   void * jresult ;
37008   Dali::Layer result;
37009
37010   {
37011     try {
37012       result = Dali::Layer::New();
37013     } catch (std::out_of_range& e) {
37014       {
37015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37016       };
37017     } catch (std::exception& e) {
37018       {
37019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37020       };
37021     } catch (Dali::DaliException e) {
37022       {
37023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37024       };
37025     } catch (...) {
37026       {
37027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37028       };
37029     }
37030   }
37031
37032   jresult = new Dali::Layer((const Dali::Layer &)result);
37033   return jresult;
37034 }
37035
37036
37037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37038   void * jresult ;
37039   Dali::BaseHandle arg1 ;
37040   Dali::BaseHandle *argp1 ;
37041   Dali::Layer result;
37042
37043   argp1 = (Dali::BaseHandle *)jarg1;
37044   if (!argp1) {
37045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37046     return 0;
37047   }
37048   arg1 = *argp1;
37049   {
37050     try {
37051       result = Dali::Layer::DownCast(arg1);
37052     } catch (std::out_of_range& e) {
37053       {
37054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37055       };
37056     } catch (std::exception& e) {
37057       {
37058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37059       };
37060     } catch (Dali::DaliException e) {
37061       {
37062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37063       };
37064     } catch (...) {
37065       {
37066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37067       };
37068     }
37069   }
37070
37071   jresult = new Dali::Layer((const Dali::Layer &)result);
37072   return jresult;
37073 }
37074
37075
37076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37077   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37078
37079   arg1 = (Dali::Layer *)jarg1;
37080   {
37081     try {
37082       delete arg1;
37083     } catch (std::out_of_range& e) {
37084       {
37085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37086       };
37087     } catch (std::exception& e) {
37088       {
37089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37090       };
37091     } catch (Dali::DaliException e) {
37092       {
37093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37094       };
37095     } catch (...) {
37096       {
37097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37098       };
37099     }
37100   }
37101
37102 }
37103
37104
37105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37106   void * jresult ;
37107   Dali::Layer *arg1 = 0 ;
37108   Dali::Layer *result = 0 ;
37109
37110   arg1 = (Dali::Layer *)jarg1;
37111   if (!arg1) {
37112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37113     return 0;
37114   }
37115   {
37116     try {
37117       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37118     } catch (std::out_of_range& e) {
37119       {
37120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37121       };
37122     } catch (std::exception& e) {
37123       {
37124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37125       };
37126     } catch (Dali::DaliException e) {
37127       {
37128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37129       };
37130     } catch (...) {
37131       {
37132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37133       };
37134     }
37135   }
37136
37137   jresult = (void *)result;
37138   return jresult;
37139 }
37140
37141
37142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37143   void * jresult ;
37144   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37145   Dali::Layer *arg2 = 0 ;
37146   Dali::Layer *result = 0 ;
37147
37148   arg1 = (Dali::Layer *)jarg1;
37149   arg2 = (Dali::Layer *)jarg2;
37150   if (!arg2) {
37151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37152     return 0;
37153   }
37154   {
37155     try {
37156       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37157     } catch (std::out_of_range& e) {
37158       {
37159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37160       };
37161     } catch (std::exception& e) {
37162       {
37163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37164       };
37165     } catch (Dali::DaliException e) {
37166       {
37167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37168       };
37169     } catch (...) {
37170       {
37171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37172       };
37173     }
37174   }
37175
37176   jresult = (void *)result;
37177   return jresult;
37178 }
37179
37180
37181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37182   unsigned int jresult ;
37183   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37184   unsigned int result;
37185
37186   arg1 = (Dali::Layer *)jarg1;
37187   {
37188     try {
37189       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
37190     } catch (std::out_of_range& e) {
37191       {
37192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37193       };
37194     } catch (std::exception& e) {
37195       {
37196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37197       };
37198     } catch (Dali::DaliException e) {
37199       {
37200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37201       };
37202     } catch (...) {
37203       {
37204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37205       };
37206     }
37207   }
37208
37209   jresult = result;
37210   return jresult;
37211 }
37212
37213
37214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37215   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37216
37217   arg1 = (Dali::Layer *)jarg1;
37218   {
37219     try {
37220       (arg1)->Raise();
37221     } catch (std::out_of_range& e) {
37222       {
37223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37224       };
37225     } catch (std::exception& e) {
37226       {
37227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37228       };
37229     } catch (Dali::DaliException e) {
37230       {
37231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37232       };
37233     } catch (...) {
37234       {
37235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37236       };
37237     }
37238   }
37239
37240 }
37241
37242
37243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37244   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37245
37246   arg1 = (Dali::Layer *)jarg1;
37247   {
37248     try {
37249       (arg1)->Lower();
37250     } catch (std::out_of_range& e) {
37251       {
37252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37253       };
37254     } catch (std::exception& e) {
37255       {
37256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37257       };
37258     } catch (Dali::DaliException e) {
37259       {
37260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37261       };
37262     } catch (...) {
37263       {
37264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37265       };
37266     }
37267   }
37268
37269 }
37270
37271
37272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37273   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37274   Dali::Layer arg2 ;
37275   Dali::Layer *argp2 ;
37276
37277   arg1 = (Dali::Layer *)jarg1;
37278   argp2 = (Dali::Layer *)jarg2;
37279   if (!argp2) {
37280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37281     return ;
37282   }
37283   arg2 = *argp2;
37284   {
37285     try {
37286       (arg1)->RaiseAbove(arg2);
37287     } catch (std::out_of_range& e) {
37288       {
37289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37290       };
37291     } catch (std::exception& e) {
37292       {
37293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37294       };
37295     } catch (Dali::DaliException e) {
37296       {
37297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37298       };
37299     } catch (...) {
37300       {
37301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37302       };
37303     }
37304   }
37305
37306 }
37307
37308
37309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37310   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37311   Dali::Layer arg2 ;
37312   Dali::Layer *argp2 ;
37313
37314   arg1 = (Dali::Layer *)jarg1;
37315   argp2 = (Dali::Layer *)jarg2;
37316   if (!argp2) {
37317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37318     return ;
37319   }
37320   arg2 = *argp2;
37321   {
37322     try {
37323       (arg1)->LowerBelow(arg2);
37324     } catch (std::out_of_range& e) {
37325       {
37326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37327       };
37328     } catch (std::exception& e) {
37329       {
37330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37331       };
37332     } catch (Dali::DaliException e) {
37333       {
37334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37335       };
37336     } catch (...) {
37337       {
37338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37339       };
37340     }
37341   }
37342
37343 }
37344
37345
37346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37347   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37348
37349   arg1 = (Dali::Layer *)jarg1;
37350   {
37351     try {
37352       (arg1)->RaiseToTop();
37353     } catch (std::out_of_range& e) {
37354       {
37355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37356       };
37357     } catch (std::exception& e) {
37358       {
37359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37360       };
37361     } catch (Dali::DaliException e) {
37362       {
37363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37364       };
37365     } catch (...) {
37366       {
37367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37368       };
37369     }
37370   }
37371
37372 }
37373
37374
37375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37376   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37377
37378   arg1 = (Dali::Layer *)jarg1;
37379   {
37380     try {
37381       (arg1)->LowerToBottom();
37382     } catch (std::out_of_range& e) {
37383       {
37384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37385       };
37386     } catch (std::exception& e) {
37387       {
37388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37389       };
37390     } catch (Dali::DaliException e) {
37391       {
37392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37393       };
37394     } catch (...) {
37395       {
37396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37397       };
37398     }
37399   }
37400
37401 }
37402
37403
37404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37405   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37406   Dali::Layer arg2 ;
37407   Dali::Layer *argp2 ;
37408
37409   arg1 = (Dali::Layer *)jarg1;
37410   argp2 = (Dali::Layer *)jarg2;
37411   if (!argp2) {
37412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37413     return ;
37414   }
37415   arg2 = *argp2;
37416   {
37417     try {
37418       (arg1)->MoveAbove(arg2);
37419     } catch (std::out_of_range& e) {
37420       {
37421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37422       };
37423     } catch (std::exception& e) {
37424       {
37425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37426       };
37427     } catch (Dali::DaliException e) {
37428       {
37429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37430       };
37431     } catch (...) {
37432       {
37433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37434       };
37435     }
37436   }
37437
37438 }
37439
37440
37441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37442   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37443   Dali::Layer arg2 ;
37444   Dali::Layer *argp2 ;
37445
37446   arg1 = (Dali::Layer *)jarg1;
37447   argp2 = (Dali::Layer *)jarg2;
37448   if (!argp2) {
37449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37450     return ;
37451   }
37452   arg2 = *argp2;
37453   {
37454     try {
37455       (arg1)->MoveBelow(arg2);
37456     } catch (std::out_of_range& e) {
37457       {
37458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37459       };
37460     } catch (std::exception& e) {
37461       {
37462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37463       };
37464     } catch (Dali::DaliException e) {
37465       {
37466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37467       };
37468     } catch (...) {
37469       {
37470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37471       };
37472     }
37473   }
37474
37475 }
37476
37477
37478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37479   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37480   Dali::Layer::Behavior arg2 ;
37481
37482   arg1 = (Dali::Layer *)jarg1;
37483   arg2 = (Dali::Layer::Behavior)jarg2;
37484   {
37485     try {
37486       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
37487     } catch (std::out_of_range& e) {
37488       {
37489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37490       };
37491     } catch (std::exception& e) {
37492       {
37493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37494       };
37495     } catch (Dali::DaliException e) {
37496       {
37497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37498       };
37499     } catch (...) {
37500       {
37501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37502       };
37503     }
37504   }
37505
37506 }
37507
37508
37509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37510   int jresult ;
37511   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37512   Dali::Layer::Behavior result;
37513
37514   arg1 = (Dali::Layer *)jarg1;
37515   {
37516     try {
37517       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
37518     } catch (std::out_of_range& e) {
37519       {
37520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37521       };
37522     } catch (std::exception& e) {
37523       {
37524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37525       };
37526     } catch (Dali::DaliException e) {
37527       {
37528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37529       };
37530     } catch (...) {
37531       {
37532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37533       };
37534     }
37535   }
37536
37537   jresult = (int)result;
37538   return jresult;
37539 }
37540
37541
37542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37543   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37544   bool arg2 ;
37545
37546   arg1 = (Dali::Layer *)jarg1;
37547   arg2 = jarg2 ? true : false;
37548   {
37549     try {
37550       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
37551     } catch (std::out_of_range& e) {
37552       {
37553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37554       };
37555     } catch (std::exception& e) {
37556       {
37557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37558       };
37559     } catch (Dali::DaliException e) {
37560       {
37561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37562       };
37563     } catch (...) {
37564       {
37565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37566       };
37567     }
37568   }
37569
37570 }
37571
37572
37573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37574   unsigned int jresult ;
37575   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37576   bool result;
37577
37578   arg1 = (Dali::Layer *)jarg1;
37579   {
37580     try {
37581       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
37582     } catch (std::out_of_range& e) {
37583       {
37584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37585       };
37586     } catch (std::exception& e) {
37587       {
37588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37589       };
37590     } catch (Dali::DaliException e) {
37591       {
37592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37593       };
37594     } catch (...) {
37595       {
37596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37597       };
37598     }
37599   }
37600
37601   jresult = result;
37602   return jresult;
37603 }
37604
37605
37606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37607   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37608   int arg2 ;
37609   int arg3 ;
37610   int arg4 ;
37611   int arg5 ;
37612
37613   arg1 = (Dali::Layer *)jarg1;
37614   arg2 = (int)jarg2;
37615   arg3 = (int)jarg3;
37616   arg4 = (int)jarg4;
37617   arg5 = (int)jarg5;
37618   {
37619     try {
37620       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
37621     } catch (std::out_of_range& e) {
37622       {
37623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37624       };
37625     } catch (std::exception& e) {
37626       {
37627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37628       };
37629     } catch (Dali::DaliException e) {
37630       {
37631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37632       };
37633     } catch (...) {
37634       {
37635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37636       };
37637     }
37638   }
37639
37640 }
37641
37642
37643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37644   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37645   Dali::ClippingBox arg2 ;
37646   Dali::ClippingBox *argp2 ;
37647
37648   arg1 = (Dali::Layer *)jarg1;
37649   argp2 = (Dali::ClippingBox *)jarg2;
37650   if (!argp2) {
37651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37652     return ;
37653   }
37654   arg2 = *argp2;
37655   {
37656     try {
37657       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
37658     } catch (std::out_of_range& e) {
37659       {
37660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37661       };
37662     } catch (std::exception& e) {
37663       {
37664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37665       };
37666     } catch (Dali::DaliException e) {
37667       {
37668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37669       };
37670     } catch (...) {
37671       {
37672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37673       };
37674     }
37675   }
37676
37677 }
37678
37679
37680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37681   void * jresult ;
37682   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37683   Dali::ClippingBox result;
37684
37685   arg1 = (Dali::Layer *)jarg1;
37686   {
37687     try {
37688       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
37689     } catch (std::out_of_range& e) {
37690       {
37691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37692       };
37693     } catch (std::exception& e) {
37694       {
37695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37696       };
37697     } catch (Dali::DaliException e) {
37698       {
37699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37700       };
37701     } catch (...) {
37702       {
37703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37704       };
37705     }
37706   }
37707
37708   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37709   return jresult;
37710 }
37711
37712
37713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37714   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37715   bool arg2 ;
37716
37717   arg1 = (Dali::Layer *)jarg1;
37718   arg2 = jarg2 ? true : false;
37719   {
37720     try {
37721       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
37722     } catch (std::out_of_range& e) {
37723       {
37724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37725       };
37726     } catch (std::exception& e) {
37727       {
37728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37729       };
37730     } catch (Dali::DaliException e) {
37731       {
37732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37733       };
37734     } catch (...) {
37735       {
37736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37737       };
37738     }
37739   }
37740
37741 }
37742
37743
37744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37745   unsigned int jresult ;
37746   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37747   bool result;
37748
37749   arg1 = (Dali::Layer *)jarg1;
37750   {
37751     try {
37752       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
37753     } catch (std::out_of_range& e) {
37754       {
37755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37756       };
37757     } catch (std::exception& e) {
37758       {
37759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37760       };
37761     } catch (Dali::DaliException e) {
37762       {
37763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37764       };
37765     } catch (...) {
37766       {
37767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37768       };
37769     }
37770   }
37771
37772   jresult = result;
37773   return jresult;
37774 }
37775
37776
37777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
37778   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37779   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
37780
37781   arg1 = (Dali::Layer *)jarg1;
37782   arg2 = (Dali::Layer::SortFunctionType)jarg2;
37783   {
37784     try {
37785       (arg1)->SetSortFunction(arg2);
37786     } catch (std::out_of_range& e) {
37787       {
37788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37789       };
37790     } catch (std::exception& e) {
37791       {
37792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37793       };
37794     } catch (Dali::DaliException e) {
37795       {
37796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37797       };
37798     } catch (...) {
37799       {
37800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37801       };
37802     }
37803   }
37804
37805 }
37806
37807
37808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
37809   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37810   bool arg2 ;
37811
37812   arg1 = (Dali::Layer *)jarg1;
37813   arg2 = jarg2 ? true : false;
37814   {
37815     try {
37816       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
37817     } catch (std::out_of_range& e) {
37818       {
37819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37820       };
37821     } catch (std::exception& e) {
37822       {
37823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37824       };
37825     } catch (Dali::DaliException e) {
37826       {
37827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37828       };
37829     } catch (...) {
37830       {
37831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37832       };
37833     }
37834   }
37835
37836 }
37837
37838
37839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
37840   unsigned int jresult ;
37841   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37842   bool result;
37843
37844   arg1 = (Dali::Layer *)jarg1;
37845   {
37846     try {
37847       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
37848     } catch (std::out_of_range& e) {
37849       {
37850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37851       };
37852     } catch (std::exception& e) {
37853       {
37854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37855       };
37856     } catch (Dali::DaliException e) {
37857       {
37858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37859       };
37860     } catch (...) {
37861       {
37862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37863       };
37864     }
37865   }
37866
37867   jresult = result;
37868   return jresult;
37869 }
37870
37871
37872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
37873   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37874   bool arg2 ;
37875
37876   arg1 = (Dali::Layer *)jarg1;
37877   arg2 = jarg2 ? true : false;
37878   {
37879     try {
37880       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
37881     } catch (std::out_of_range& e) {
37882       {
37883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37884       };
37885     } catch (std::exception& e) {
37886       {
37887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37888       };
37889     } catch (Dali::DaliException e) {
37890       {
37891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37892       };
37893     } catch (...) {
37894       {
37895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37896       };
37897     }
37898   }
37899
37900 }
37901
37902
37903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
37904   unsigned int jresult ;
37905   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37906   bool result;
37907
37908   arg1 = (Dali::Layer *)jarg1;
37909   {
37910     try {
37911       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
37912     } catch (std::out_of_range& e) {
37913       {
37914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37915       };
37916     } catch (std::exception& e) {
37917       {
37918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37919       };
37920     } catch (Dali::DaliException e) {
37921       {
37922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37923       };
37924     } catch (...) {
37925       {
37926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37927       };
37928     }
37929   }
37930
37931   jresult = result;
37932   return jresult;
37933 }
37934
37935
37936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
37937   void * jresult ;
37938   Dali::Stage result;
37939
37940   {
37941     try {
37942       result = Dali::Stage::GetCurrent();
37943     } catch (std::out_of_range& e) {
37944       {
37945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37946       };
37947     } catch (std::exception& e) {
37948       {
37949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37950       };
37951     } catch (Dali::DaliException e) {
37952       {
37953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37954       };
37955     } catch (...) {
37956       {
37957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37958       };
37959     }
37960   }
37961
37962   jresult = new Dali::Stage((const Dali::Stage &)result);
37963   return jresult;
37964 }
37965
37966
37967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
37968   unsigned int jresult ;
37969   bool result;
37970
37971   {
37972     try {
37973       result = (bool)Dali::Stage::IsInstalled();
37974     } catch (std::out_of_range& e) {
37975       {
37976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37977       };
37978     } catch (std::exception& e) {
37979       {
37980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37981       };
37982     } catch (Dali::DaliException e) {
37983       {
37984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37985       };
37986     } catch (...) {
37987       {
37988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37989       };
37990     }
37991   }
37992
37993   jresult = result;
37994   return jresult;
37995 }
37996
37997
37998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
37999   void * jresult ;
38000   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38001   Dali::Vector2 result;
38002
38003   arg1 = (Dali::Stage *)jarg1;
38004   {
38005     try {
38006       result = ((Dali::Stage const *)arg1)->GetDpi();
38007     } catch (std::out_of_range& e) {
38008       {
38009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38010       };
38011     } catch (std::exception& e) {
38012       {
38013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38014       };
38015     } catch (Dali::DaliException e) {
38016       {
38017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38018       };
38019     } catch (...) {
38020       {
38021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38022       };
38023     }
38024   }
38025
38026   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38027   return jresult;
38028 }
38029
38030
38031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38032   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38033   float arg2 ;
38034
38035   arg1 = (Dali::Stage *)jarg1;
38036   arg2 = (float)jarg2;
38037   {
38038     try {
38039       (arg1)->KeepRendering(arg2);
38040     } catch (std::out_of_range& e) {
38041       {
38042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38043       };
38044     } catch (std::exception& e) {
38045       {
38046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38047       };
38048     } catch (Dali::DaliException e) {
38049       {
38050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38051       };
38052     } catch (...) {
38053       {
38054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38055       };
38056     }
38057   }
38058
38059 }
38060
38061
38062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38063   void * jresult ;
38064   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38065   Dali::Stage::KeyEventSignalType *result = 0 ;
38066
38067   arg1 = (Dali::Stage *)jarg1;
38068   {
38069     try {
38070       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38071     } catch (std::out_of_range& e) {
38072       {
38073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38074       };
38075     } catch (std::exception& e) {
38076       {
38077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38078       };
38079     } catch (Dali::DaliException e) {
38080       {
38081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38082       };
38083     } catch (...) {
38084       {
38085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38086       };
38087     }
38088   }
38089
38090   jresult = (void *)result;
38091   return jresult;
38092 }
38093
38094
38095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38096   void * jresult ;
38097   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38098   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38099
38100   arg1 = (Dali::Stage *)jarg1;
38101   {
38102     try {
38103       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38104     } catch (std::out_of_range& e) {
38105       {
38106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38107       };
38108     } catch (std::exception& e) {
38109       {
38110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38111       };
38112     } catch (Dali::DaliException e) {
38113       {
38114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38115       };
38116     } catch (...) {
38117       {
38118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38119       };
38120     }
38121   }
38122
38123   jresult = (void *)result;
38124   return jresult;
38125 }
38126
38127
38128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38129   void * jresult ;
38130   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38131   Dali::Stage::TouchSignalType *result = 0 ;
38132
38133   arg1 = (Dali::Stage *)jarg1;
38134   {
38135     try {
38136       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38137     } catch (std::out_of_range& e) {
38138       {
38139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38140       };
38141     } catch (std::exception& e) {
38142       {
38143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38144       };
38145     } catch (Dali::DaliException e) {
38146       {
38147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38148       };
38149     } catch (...) {
38150       {
38151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38152       };
38153     }
38154   }
38155
38156   jresult = (void *)result;
38157   return jresult;
38158 }
38159
38160
38161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38162   void * jresult ;
38163   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38164   Dali::Stage::WheelEventSignalType *result = 0 ;
38165
38166   arg1 = (Dali::Stage *)jarg1;
38167   {
38168     try {
38169       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38170     } catch (std::out_of_range& e) {
38171       {
38172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38173       };
38174     } catch (std::exception& e) {
38175       {
38176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38177       };
38178     } catch (Dali::DaliException e) {
38179       {
38180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38181       };
38182     } catch (...) {
38183       {
38184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38185       };
38186     }
38187   }
38188
38189   jresult = (void *)result;
38190   return jresult;
38191 }
38192
38193
38194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38195   void * jresult ;
38196   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38197   Dali::Stage::ContextStatusSignal *result = 0 ;
38198
38199   arg1 = (Dali::Stage *)jarg1;
38200   {
38201     try {
38202       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38203     } catch (std::out_of_range& e) {
38204       {
38205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38206       };
38207     } catch (std::exception& e) {
38208       {
38209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38210       };
38211     } catch (Dali::DaliException e) {
38212       {
38213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38214       };
38215     } catch (...) {
38216       {
38217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38218       };
38219     }
38220   }
38221
38222   jresult = (void *)result;
38223   return jresult;
38224 }
38225
38226
38227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38228   void * jresult ;
38229   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38230   Dali::Stage::ContextStatusSignal *result = 0 ;
38231
38232   arg1 = (Dali::Stage *)jarg1;
38233   {
38234     try {
38235       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38236     } catch (std::out_of_range& e) {
38237       {
38238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38239       };
38240     } catch (std::exception& e) {
38241       {
38242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38243       };
38244     } catch (Dali::DaliException e) {
38245       {
38246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38247       };
38248     } catch (...) {
38249       {
38250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38251       };
38252     }
38253   }
38254
38255   jresult = (void *)result;
38256   return jresult;
38257 }
38258
38259
38260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38261   void * jresult ;
38262   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38263   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38264
38265   arg1 = (Dali::Stage *)jarg1;
38266   {
38267     try {
38268       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
38269     } catch (std::out_of_range& e) {
38270       {
38271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38272       };
38273     } catch (std::exception& e) {
38274       {
38275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38276       };
38277     } catch (Dali::DaliException e) {
38278       {
38279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38280       };
38281     } catch (...) {
38282       {
38283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38284       };
38285     }
38286   }
38287
38288   jresult = (void *)result;
38289   return jresult;
38290 }
38291
38292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
38293   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38294   Dali::DevelStage::Rendering arg2 ;
38295
38296   arg1 = (Dali::Stage *)jarg1;
38297   arg2 = (Dali::DevelStage::Rendering)jarg2;
38298   {
38299     try {
38300       DevelStage::SetRenderingBehavior(*arg1,arg2);
38301     } catch (std::out_of_range& e) {
38302       {
38303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38304       };
38305     } catch (std::exception& e) {
38306       {
38307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38308       };
38309     } catch (Dali::DaliException e) {
38310       {
38311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38312       };
38313     } catch (...) {
38314       {
38315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38316       };
38317     }
38318   }
38319
38320 }
38321
38322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
38323
38324   int jresult ;
38325   int result ;
38326   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38327
38328   arg1 = (Dali::Stage *)jarg1;
38329   {
38330     try {
38331       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
38332     } catch (std::out_of_range& e) {
38333       {
38334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38335       };
38336     } catch (std::exception& e) {
38337       {
38338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38339       };
38340     } catch (Dali::DaliException e) {
38341       {
38342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38343       };
38344     } catch (...) {
38345       {
38346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38347       };
38348     }
38349   }
38350
38351   jresult = result;
38352   return jresult;
38353 }
38354
38355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
38356   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38357
38358   arg1 = (Dali::RelayoutContainer *)jarg1;
38359   {
38360     try {
38361       delete arg1;
38362     } catch (std::out_of_range& e) {
38363       {
38364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38365       };
38366     } catch (std::exception& e) {
38367       {
38368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38369       };
38370     } catch (Dali::DaliException e) {
38371       {
38372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38373       };
38374     } catch (...) {
38375       {
38376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38377       };
38378     }
38379   }
38380
38381 }
38382
38383
38384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
38385   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38386   Dali::Actor *arg2 = 0 ;
38387   Dali::Vector2 *arg3 = 0 ;
38388
38389   arg1 = (Dali::RelayoutContainer *)jarg1;
38390   arg2 = (Dali::Actor *)jarg2;
38391   if (!arg2) {
38392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38393     return ;
38394   }
38395   arg3 = (Dali::Vector2 *)jarg3;
38396   if (!arg3) {
38397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38398     return ;
38399   }
38400   {
38401     try {
38402       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
38403     } catch (std::out_of_range& e) {
38404       {
38405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38406       };
38407     } catch (std::exception& e) {
38408       {
38409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38410       };
38411     } catch (Dali::DaliException e) {
38412       {
38413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38414       };
38415     } catch (...) {
38416       {
38417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38418       };
38419     }
38420   }
38421
38422 }
38423
38424
38425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
38426   void * jresult ;
38427   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38428   Dali::CustomActor result;
38429
38430   arg1 = (Dali::CustomActorImpl *)jarg1;
38431   {
38432     try {
38433       result = ((Dali::CustomActorImpl const *)arg1)->Self();
38434     } catch (std::out_of_range& e) {
38435       {
38436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38437       };
38438     } catch (std::exception& e) {
38439       {
38440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38441       };
38442     } catch (Dali::DaliException e) {
38443       {
38444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38445       };
38446     } catch (...) {
38447       {
38448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38449       };
38450     }
38451   }
38452
38453   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
38454   return jresult;
38455 }
38456
38457
38458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
38459   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38460   int arg2 ;
38461
38462   arg1 = (Dali::CustomActorImpl *)jarg1;
38463   arg2 = (int)jarg2;
38464   {
38465     try {
38466       (arg1)->OnSceneConnection(arg2);
38467     } catch (std::out_of_range& e) {
38468       {
38469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38470       };
38471     } catch (std::exception& e) {
38472       {
38473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38474       };
38475     } catch (Dali::DaliException e) {
38476       {
38477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38478       };
38479     } catch (...) {
38480       {
38481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38482       };
38483     }
38484   }
38485
38486 }
38487
38488
38489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
38490   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38491
38492   arg1 = (Dali::CustomActorImpl *)jarg1;
38493   {
38494     try {
38495       (arg1)->OnSceneDisconnection();
38496     } catch (std::out_of_range& e) {
38497       {
38498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38499       };
38500     } catch (std::exception& e) {
38501       {
38502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38503       };
38504     } catch (Dali::DaliException e) {
38505       {
38506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38507       };
38508     } catch (...) {
38509       {
38510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38511       };
38512     }
38513   }
38514
38515 }
38516
38517
38518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
38519   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38520   Dali::Actor *arg2 = 0 ;
38521
38522   arg1 = (Dali::CustomActorImpl *)jarg1;
38523   arg2 = (Dali::Actor *)jarg2;
38524   if (!arg2) {
38525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38526     return ;
38527   }
38528   {
38529     try {
38530       (arg1)->OnChildAdd(*arg2);
38531     } catch (std::out_of_range& e) {
38532       {
38533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38534       };
38535     } catch (std::exception& e) {
38536       {
38537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38538       };
38539     } catch (Dali::DaliException e) {
38540       {
38541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38542       };
38543     } catch (...) {
38544       {
38545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38546       };
38547     }
38548   }
38549
38550 }
38551
38552
38553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
38554   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38555   Dali::Actor *arg2 = 0 ;
38556
38557   arg1 = (Dali::CustomActorImpl *)jarg1;
38558   arg2 = (Dali::Actor *)jarg2;
38559   if (!arg2) {
38560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38561     return ;
38562   }
38563   {
38564     try {
38565       (arg1)->OnChildRemove(*arg2);
38566     } catch (std::out_of_range& e) {
38567       {
38568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38569       };
38570     } catch (std::exception& e) {
38571       {
38572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38573       };
38574     } catch (Dali::DaliException e) {
38575       {
38576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38577       };
38578     } catch (...) {
38579       {
38580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38581       };
38582     }
38583   }
38584
38585 }
38586
38587
38588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
38589   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38590   Dali::Property::Index arg2 ;
38591   Dali::Property::Value arg3 ;
38592   Dali::Property::Value *argp3 ;
38593
38594   arg1 = (Dali::CustomActorImpl *)jarg1;
38595   arg2 = (Dali::Property::Index)jarg2;
38596   argp3 = (Dali::Property::Value *)jarg3;
38597   if (!argp3) {
38598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
38599     return ;
38600   }
38601   arg3 = *argp3;
38602   {
38603     try {
38604       (arg1)->OnPropertySet(arg2,arg3);
38605     } catch (std::out_of_range& e) {
38606       {
38607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38608       };
38609     } catch (std::exception& e) {
38610       {
38611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38612       };
38613     } catch (Dali::DaliException e) {
38614       {
38615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38616       };
38617     } catch (...) {
38618       {
38619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38620       };
38621     }
38622   }
38623
38624 }
38625
38626
38627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
38628   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38629   Dali::Vector3 *arg2 = 0 ;
38630
38631   arg1 = (Dali::CustomActorImpl *)jarg1;
38632   arg2 = (Dali::Vector3 *)jarg2;
38633   if (!arg2) {
38634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38635     return ;
38636   }
38637   {
38638     try {
38639       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
38640     } catch (std::out_of_range& e) {
38641       {
38642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38643       };
38644     } catch (std::exception& e) {
38645       {
38646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38647       };
38648     } catch (Dali::DaliException e) {
38649       {
38650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38651       };
38652     } catch (...) {
38653       {
38654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38655       };
38656     }
38657   }
38658
38659 }
38660
38661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
38662   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38663   Dali::Animation *arg2 = 0 ;
38664   Dali::Vector3 *arg3 = 0 ;
38665
38666   arg1 = (Dali::CustomActorImpl *)jarg1;
38667   arg2 = (Dali::Animation *)jarg2;
38668   if (!arg2) {
38669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
38670     return ;
38671   }
38672   arg3 = (Dali::Vector3 *)jarg3;
38673   if (!arg3) {
38674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38675     return ;
38676   }
38677   {
38678     try {
38679       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
38680     } catch (std::out_of_range& e) {
38681       {
38682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38683       };
38684     } catch (std::exception& e) {
38685       {
38686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38687       };
38688     } catch (Dali::DaliException e) {
38689       {
38690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38691       };
38692     } catch (...) {
38693       {
38694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38695       };
38696     }
38697   }
38698 }
38699
38700 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
38701   unsigned int jresult ;
38702   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38703   Dali::HoverEvent *arg2 = 0 ;
38704   bool result;
38705
38706   arg1 = (Dali::CustomActorImpl *)jarg1;
38707   arg2 = (Dali::HoverEvent *)jarg2;
38708   if (!arg2) {
38709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
38710     return 0;
38711   }
38712   {
38713     try {
38714       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
38715     } catch (std::out_of_range& e) {
38716       {
38717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38718       };
38719     } catch (std::exception& e) {
38720       {
38721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38722       };
38723     } catch (Dali::DaliException e) {
38724       {
38725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38726       };
38727     } catch (...) {
38728       {
38729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38730       };
38731     }
38732   }
38733
38734   jresult = result;
38735   return jresult;
38736 }
38737
38738
38739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
38740   unsigned int jresult ;
38741   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38742   Dali::KeyEvent *arg2 = 0 ;
38743   bool result;
38744
38745   arg1 = (Dali::CustomActorImpl *)jarg1;
38746   arg2 = (Dali::KeyEvent *)jarg2;
38747   if (!arg2) {
38748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
38749     return 0;
38750   }
38751   {
38752     try {
38753       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
38754     } catch (std::out_of_range& e) {
38755       {
38756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38757       };
38758     } catch (std::exception& e) {
38759       {
38760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38761       };
38762     } catch (Dali::DaliException e) {
38763       {
38764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38765       };
38766     } catch (...) {
38767       {
38768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38769       };
38770     }
38771   }
38772
38773   jresult = result;
38774   return jresult;
38775 }
38776
38777
38778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
38779   unsigned int jresult ;
38780   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38781   Dali::WheelEvent *arg2 = 0 ;
38782   bool result;
38783
38784   arg1 = (Dali::CustomActorImpl *)jarg1;
38785   arg2 = (Dali::WheelEvent *)jarg2;
38786   if (!arg2) {
38787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
38788     return 0;
38789   }
38790   {
38791     try {
38792       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
38793     } catch (std::out_of_range& e) {
38794       {
38795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38796       };
38797     } catch (std::exception& e) {
38798       {
38799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38800       };
38801     } catch (Dali::DaliException e) {
38802       {
38803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38804       };
38805     } catch (...) {
38806       {
38807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38808       };
38809     }
38810   }
38811
38812   jresult = result;
38813   return jresult;
38814 }
38815
38816
38817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
38818   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38819   Dali::Vector2 *arg2 = 0 ;
38820   Dali::RelayoutContainer *arg3 = 0 ;
38821
38822   arg1 = (Dali::CustomActorImpl *)jarg1;
38823   arg2 = (Dali::Vector2 *)jarg2;
38824   if (!arg2) {
38825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38826     return ;
38827   }
38828   arg3 = (Dali::RelayoutContainer *)jarg3;
38829   if (!arg3) {
38830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
38831     return ;
38832   }
38833   {
38834     try {
38835       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
38836     } catch (std::out_of_range& e) {
38837       {
38838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38839       };
38840     } catch (std::exception& e) {
38841       {
38842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38843       };
38844     } catch (Dali::DaliException e) {
38845       {
38846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38847       };
38848     } catch (...) {
38849       {
38850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38851       };
38852     }
38853   }
38854
38855 }
38856
38857
38858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
38859   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38860   Dali::ResizePolicy::Type arg2 ;
38861   Dali::Dimension::Type arg3 ;
38862
38863   arg1 = (Dali::CustomActorImpl *)jarg1;
38864   arg2 = (Dali::ResizePolicy::Type)jarg2;
38865   arg3 = (Dali::Dimension::Type)jarg3;
38866   {
38867     try {
38868       (arg1)->OnSetResizePolicy(arg2,arg3);
38869     } catch (std::out_of_range& e) {
38870       {
38871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38872       };
38873     } catch (std::exception& e) {
38874       {
38875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38876       };
38877     } catch (Dali::DaliException e) {
38878       {
38879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38880       };
38881     } catch (...) {
38882       {
38883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38884       };
38885     }
38886   }
38887
38888 }
38889
38890
38891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
38892   void * jresult ;
38893   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38894   Dali::Vector3 result;
38895
38896   arg1 = (Dali::CustomActorImpl *)jarg1;
38897   {
38898     try {
38899       result = (arg1)->GetNaturalSize();
38900     } catch (std::out_of_range& e) {
38901       {
38902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38903       };
38904     } catch (std::exception& e) {
38905       {
38906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38907       };
38908     } catch (Dali::DaliException e) {
38909       {
38910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38911       };
38912     } catch (...) {
38913       {
38914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38915       };
38916     }
38917   }
38918
38919   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
38920   return jresult;
38921 }
38922
38923
38924 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
38925   float jresult ;
38926   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38927   Dali::Actor *arg2 = 0 ;
38928   Dali::Dimension::Type arg3 ;
38929   float result;
38930
38931   arg1 = (Dali::CustomActorImpl *)jarg1;
38932   arg2 = (Dali::Actor *)jarg2;
38933   if (!arg2) {
38934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38935     return 0;
38936   }
38937   arg3 = (Dali::Dimension::Type)jarg3;
38938   {
38939     try {
38940       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
38941     } catch (std::out_of_range& e) {
38942       {
38943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38944       };
38945     } catch (std::exception& e) {
38946       {
38947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38948       };
38949     } catch (Dali::DaliException e) {
38950       {
38951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38952       };
38953     } catch (...) {
38954       {
38955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38956       };
38957     }
38958   }
38959
38960   jresult = result;
38961   return jresult;
38962 }
38963
38964
38965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
38966   float jresult ;
38967   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38968   float arg2 ;
38969   float result;
38970
38971   arg1 = (Dali::CustomActorImpl *)jarg1;
38972   arg2 = (float)jarg2;
38973   {
38974     try {
38975       result = (float)(arg1)->GetHeightForWidth(arg2);
38976     } catch (std::out_of_range& e) {
38977       {
38978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38979       };
38980     } catch (std::exception& e) {
38981       {
38982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38983       };
38984     } catch (Dali::DaliException e) {
38985       {
38986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38987       };
38988     } catch (...) {
38989       {
38990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38991       };
38992     }
38993   }
38994
38995   jresult = result;
38996   return jresult;
38997 }
38998
38999
39000 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39001   float jresult ;
39002   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39003   float arg2 ;
39004   float result;
39005
39006   arg1 = (Dali::CustomActorImpl *)jarg1;
39007   arg2 = (float)jarg2;
39008   {
39009     try {
39010       result = (float)(arg1)->GetWidthForHeight(arg2);
39011     } catch (std::out_of_range& e) {
39012       {
39013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39014       };
39015     } catch (std::exception& e) {
39016       {
39017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39018       };
39019     } catch (Dali::DaliException e) {
39020       {
39021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39022       };
39023     } catch (...) {
39024       {
39025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39026       };
39027     }
39028   }
39029
39030   jresult = result;
39031   return jresult;
39032 }
39033
39034
39035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39036   unsigned int jresult ;
39037   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39038   Dali::Dimension::Type arg2 ;
39039   bool result;
39040
39041   arg1 = (Dali::CustomActorImpl *)jarg1;
39042   arg2 = (Dali::Dimension::Type)jarg2;
39043   {
39044     try {
39045       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39046     } catch (std::out_of_range& e) {
39047       {
39048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39049       };
39050     } catch (std::exception& e) {
39051       {
39052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39053       };
39054     } catch (Dali::DaliException e) {
39055       {
39056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39057       };
39058     } catch (...) {
39059       {
39060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39061       };
39062     }
39063   }
39064
39065   jresult = result;
39066   return jresult;
39067 }
39068
39069
39070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39071   unsigned int jresult ;
39072   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39073   bool result;
39074
39075   arg1 = (Dali::CustomActorImpl *)jarg1;
39076   {
39077     try {
39078       result = (bool)(arg1)->RelayoutDependentOnChildren();
39079     } catch (std::out_of_range& e) {
39080       {
39081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39082       };
39083     } catch (std::exception& e) {
39084       {
39085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39086       };
39087     } catch (Dali::DaliException e) {
39088       {
39089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39090       };
39091     } catch (...) {
39092       {
39093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39094       };
39095     }
39096   }
39097
39098   jresult = result;
39099   return jresult;
39100 }
39101
39102
39103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39104   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39105   Dali::Dimension::Type arg2 ;
39106
39107   arg1 = (Dali::CustomActorImpl *)jarg1;
39108   arg2 = (Dali::Dimension::Type)jarg2;
39109   {
39110     try {
39111       (arg1)->OnCalculateRelayoutSize(arg2);
39112     } catch (std::out_of_range& e) {
39113       {
39114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39115       };
39116     } catch (std::exception& e) {
39117       {
39118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39119       };
39120     } catch (Dali::DaliException e) {
39121       {
39122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39123       };
39124     } catch (...) {
39125       {
39126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39127       };
39128     }
39129   }
39130
39131 }
39132
39133
39134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39135   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39136   float arg2 ;
39137   Dali::Dimension::Type arg3 ;
39138
39139   arg1 = (Dali::CustomActorImpl *)jarg1;
39140   arg2 = (float)jarg2;
39141   arg3 = (Dali::Dimension::Type)jarg3;
39142   {
39143     try {
39144       (arg1)->OnLayoutNegotiated(arg2,arg3);
39145     } catch (std::out_of_range& e) {
39146       {
39147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39148       };
39149     } catch (std::exception& e) {
39150       {
39151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39152       };
39153     } catch (Dali::DaliException e) {
39154       {
39155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39156       };
39157     } catch (...) {
39158       {
39159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39160       };
39161     }
39162   }
39163
39164 }
39165
39166
39167 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39168   unsigned int jresult ;
39169   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39170   bool result;
39171
39172   arg1 = (Dali::CustomActorImpl *)jarg1;
39173   {
39174     try {
39175       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39176     } catch (std::out_of_range& e) {
39177       {
39178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39179       };
39180     } catch (std::exception& e) {
39181       {
39182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39183       };
39184     } catch (Dali::DaliException e) {
39185       {
39186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39187       };
39188     } catch (...) {
39189       {
39190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39191       };
39192     }
39193   }
39194
39195   jresult = result;
39196   return jresult;
39197 }
39198
39199
39200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39201   unsigned int jresult ;
39202   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39203   bool result;
39204
39205   arg1 = (Dali::CustomActorImpl *)jarg1;
39206   {
39207     try {
39208       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39209     } catch (std::out_of_range& e) {
39210       {
39211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39212       };
39213     } catch (std::exception& e) {
39214       {
39215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39216       };
39217     } catch (Dali::DaliException e) {
39218       {
39219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39220       };
39221     } catch (...) {
39222       {
39223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39224       };
39225     }
39226   }
39227
39228   jresult = result;
39229   return jresult;
39230 }
39231
39232
39233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39234   unsigned int jresult ;
39235   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39236   bool result;
39237
39238   arg1 = (Dali::CustomActorImpl *)jarg1;
39239   {
39240     try {
39241       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39242     } catch (std::out_of_range& e) {
39243       {
39244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39245       };
39246     } catch (std::exception& e) {
39247       {
39248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39249       };
39250     } catch (Dali::DaliException e) {
39251       {
39252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39253       };
39254     } catch (...) {
39255       {
39256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39257       };
39258     }
39259   }
39260
39261   jresult = result;
39262   return jresult;
39263 }
39264
39265
39266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
39267   unsigned int jresult ;
39268   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39269   bool result;
39270
39271   arg1 = (Dali::CustomActorImpl *)jarg1;
39272   {
39273     try {
39274       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
39275     } catch (std::out_of_range& e) {
39276       {
39277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39278       };
39279     } catch (std::exception& e) {
39280       {
39281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39282       };
39283     } catch (Dali::DaliException e) {
39284       {
39285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39286       };
39287     } catch (...) {
39288       {
39289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39290       };
39291     }
39292   }
39293
39294   jresult = result;
39295   return jresult;
39296 }
39297
39298
39299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
39300   void * jresult ;
39301   Dali::CustomActor *result = 0 ;
39302
39303   {
39304     try {
39305       result = (Dali::CustomActor *)new Dali::CustomActor();
39306     } catch (std::out_of_range& e) {
39307       {
39308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39309       };
39310     } catch (std::exception& e) {
39311       {
39312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39313       };
39314     } catch (Dali::DaliException e) {
39315       {
39316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39317       };
39318     } catch (...) {
39319       {
39320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39321       };
39322     }
39323   }
39324
39325   jresult = (void *)result;
39326   return jresult;
39327 }
39328
39329
39330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
39331   void * jresult ;
39332   Dali::BaseHandle arg1 ;
39333   Dali::BaseHandle *argp1 ;
39334   Dali::CustomActor result;
39335
39336   argp1 = (Dali::BaseHandle *)jarg1;
39337   if (!argp1) {
39338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39339     return 0;
39340   }
39341   arg1 = *argp1;
39342   {
39343     try {
39344       result = Dali::CustomActor::DownCast(arg1);
39345     } catch (std::out_of_range& e) {
39346       {
39347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39348       };
39349     } catch (std::exception& e) {
39350       {
39351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39352       };
39353     } catch (Dali::DaliException e) {
39354       {
39355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39356       };
39357     } catch (...) {
39358       {
39359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39360       };
39361     }
39362   }
39363
39364   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39365   return jresult;
39366 }
39367
39368
39369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
39370   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39371
39372   arg1 = (Dali::CustomActor *)jarg1;
39373   {
39374     try {
39375       delete arg1;
39376     } catch (std::out_of_range& e) {
39377       {
39378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39379       };
39380     } catch (std::exception& e) {
39381       {
39382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39383       };
39384     } catch (Dali::DaliException e) {
39385       {
39386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39387       };
39388     } catch (...) {
39389       {
39390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39391       };
39392     }
39393   }
39394
39395 }
39396
39397
39398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
39399   void * jresult ;
39400   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39401   Dali::CustomActorImpl *result = 0 ;
39402
39403   arg1 = (Dali::CustomActor *)jarg1;
39404   {
39405     try {
39406       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
39407     } catch (std::out_of_range& e) {
39408       {
39409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39410       };
39411     } catch (std::exception& e) {
39412       {
39413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39414       };
39415     } catch (Dali::DaliException e) {
39416       {
39417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39418       };
39419     } catch (...) {
39420       {
39421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39422       };
39423     }
39424   }
39425
39426   jresult = (void *)result;
39427   return jresult;
39428 }
39429
39430
39431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
39432   void * jresult ;
39433   Dali::CustomActorImpl *arg1 = 0 ;
39434   Dali::CustomActor *result = 0 ;
39435
39436   arg1 = (Dali::CustomActorImpl *)jarg1;
39437   if (!arg1) {
39438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
39439     return 0;
39440   }
39441   {
39442     try {
39443       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
39444     } catch (std::out_of_range& e) {
39445       {
39446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39447       };
39448     } catch (std::exception& e) {
39449       {
39450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39451       };
39452     } catch (Dali::DaliException e) {
39453       {
39454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39455       };
39456     } catch (...) {
39457       {
39458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39459       };
39460     }
39461   }
39462
39463   jresult = (void *)result;
39464   return jresult;
39465 }
39466
39467
39468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
39469   void * jresult ;
39470   Dali::CustomActor *arg1 = 0 ;
39471   Dali::CustomActor *result = 0 ;
39472
39473   arg1 = (Dali::CustomActor *)jarg1;
39474   if (!arg1) {
39475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39476     return 0;
39477   }
39478   {
39479     try {
39480       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
39481     } catch (std::out_of_range& e) {
39482       {
39483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39484       };
39485     } catch (std::exception& e) {
39486       {
39487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39488       };
39489     } catch (Dali::DaliException e) {
39490       {
39491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39492       };
39493     } catch (...) {
39494       {
39495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39496       };
39497     }
39498   }
39499
39500   jresult = (void *)result;
39501   return jresult;
39502 }
39503
39504
39505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
39506   void * jresult ;
39507   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39508   Dali::CustomActor *arg2 = 0 ;
39509   Dali::CustomActor *result = 0 ;
39510
39511   arg1 = (Dali::CustomActor *)jarg1;
39512   arg2 = (Dali::CustomActor *)jarg2;
39513   if (!arg2) {
39514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39515     return 0;
39516   }
39517   {
39518     try {
39519       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
39520     } catch (std::out_of_range& e) {
39521       {
39522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39523       };
39524     } catch (std::exception& e) {
39525       {
39526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39527       };
39528     } catch (Dali::DaliException e) {
39529       {
39530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39531       };
39532     } catch (...) {
39533       {
39534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39535       };
39536     }
39537   }
39538
39539   jresult = (void *)result;
39540   return jresult;
39541 }
39542
39543
39544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
39545   int jresult ;
39546   int result;
39547
39548   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
39549   jresult = (int)result;
39550   return jresult;
39551 }
39552
39553
39554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
39555   int jresult ;
39556   int result;
39557
39558   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
39559   jresult = (int)result;
39560   return jresult;
39561 }
39562
39563
39564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
39565   int jresult ;
39566   int result;
39567
39568   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
39569   jresult = (int)result;
39570   return jresult;
39571 }
39572
39573
39574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
39575   int jresult ;
39576   int result;
39577
39578   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
39579   jresult = (int)result;
39580   return jresult;
39581 }
39582
39583
39584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
39585   int jresult ;
39586   int result;
39587
39588   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
39589   jresult = (int)result;
39590   return jresult;
39591 }
39592
39593
39594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
39595   int jresult ;
39596   int result;
39597
39598   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
39599   jresult = (int)result;
39600   return jresult;
39601 }
39602
39603
39604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
39605   int jresult ;
39606   int result;
39607
39608   result = (int)Dali::PanGestureDetector::Property::PANNING;
39609   jresult = (int)result;
39610   return jresult;
39611 }
39612
39613
39614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
39615   void * jresult ;
39616   Dali::PanGestureDetector::Property *result = 0 ;
39617
39618   {
39619     try {
39620       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
39621     } catch (std::out_of_range& e) {
39622       {
39623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39624       };
39625     } catch (std::exception& e) {
39626       {
39627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39628       };
39629     } catch (Dali::DaliException e) {
39630       {
39631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39632       };
39633     } catch (...) {
39634       {
39635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39636       };
39637     }
39638   }
39639
39640   jresult = (void *)result;
39641   return jresult;
39642 }
39643
39644
39645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
39646   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
39647
39648   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
39649   {
39650     try {
39651       delete arg1;
39652     } catch (std::out_of_range& e) {
39653       {
39654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39655       };
39656     } catch (std::exception& e) {
39657       {
39658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39659       };
39660     } catch (Dali::DaliException e) {
39661       {
39662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39663       };
39664     } catch (...) {
39665       {
39666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39667       };
39668     }
39669   }
39670
39671 }
39672
39673
39674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
39675   void * jresult ;
39676   Dali::Radian *result = 0 ;
39677
39678   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
39679   jresult = (void *)result;
39680   return jresult;
39681 }
39682
39683
39684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
39685   void * jresult ;
39686   Dali::Radian *result = 0 ;
39687
39688   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
39689   jresult = (void *)result;
39690   return jresult;
39691 }
39692
39693
39694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
39695   void * jresult ;
39696   Dali::Radian *result = 0 ;
39697
39698   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
39699   jresult = (void *)result;
39700   return jresult;
39701 }
39702
39703
39704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
39705   void * jresult ;
39706   Dali::Radian *result = 0 ;
39707
39708   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
39709   jresult = (void *)result;
39710   return jresult;
39711 }
39712
39713
39714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
39715   void * jresult ;
39716   Dali::Radian *result = 0 ;
39717
39718   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
39719   jresult = (void *)result;
39720   return jresult;
39721 }
39722
39723
39724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
39725   void * jresult ;
39726   Dali::Radian *result = 0 ;
39727
39728   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
39729   jresult = (void *)result;
39730   return jresult;
39731 }
39732
39733
39734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
39735   void * jresult ;
39736   Dali::Radian *result = 0 ;
39737
39738   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
39739   jresult = (void *)result;
39740   return jresult;
39741 }
39742
39743
39744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
39745   void * jresult ;
39746   Dali::PanGestureDetector *result = 0 ;
39747
39748   {
39749     try {
39750       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
39751     } catch (std::out_of_range& e) {
39752       {
39753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39754       };
39755     } catch (std::exception& e) {
39756       {
39757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39758       };
39759     } catch (Dali::DaliException e) {
39760       {
39761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39762       };
39763     } catch (...) {
39764       {
39765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39766       };
39767     }
39768   }
39769
39770   jresult = (void *)result;
39771   return jresult;
39772 }
39773
39774
39775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
39776   void * jresult ;
39777   Dali::PanGestureDetector result;
39778
39779   {
39780     try {
39781       result = Dali::PanGestureDetector::New();
39782     } catch (std::out_of_range& e) {
39783       {
39784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39785       };
39786     } catch (std::exception& e) {
39787       {
39788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39789       };
39790     } catch (Dali::DaliException e) {
39791       {
39792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39793       };
39794     } catch (...) {
39795       {
39796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39797       };
39798     }
39799   }
39800
39801   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
39802   return jresult;
39803 }
39804
39805
39806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
39807   void * jresult ;
39808   Dali::BaseHandle arg1 ;
39809   Dali::BaseHandle *argp1 ;
39810   Dali::PanGestureDetector result;
39811
39812   argp1 = (Dali::BaseHandle *)jarg1;
39813   if (!argp1) {
39814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39815     return 0;
39816   }
39817   arg1 = *argp1;
39818   {
39819     try {
39820       result = Dali::PanGestureDetector::DownCast(arg1);
39821     } catch (std::out_of_range& e) {
39822       {
39823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39824       };
39825     } catch (std::exception& e) {
39826       {
39827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39828       };
39829     } catch (Dali::DaliException e) {
39830       {
39831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39832       };
39833     } catch (...) {
39834       {
39835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39836       };
39837     }
39838   }
39839
39840   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
39841   return jresult;
39842 }
39843
39844
39845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
39846   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
39847
39848   arg1 = (Dali::PanGestureDetector *)jarg1;
39849   {
39850     try {
39851       delete arg1;
39852     } catch (std::out_of_range& e) {
39853       {
39854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39855       };
39856     } catch (std::exception& e) {
39857       {
39858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39859       };
39860     } catch (Dali::DaliException e) {
39861       {
39862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39863       };
39864     } catch (...) {
39865       {
39866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39867       };
39868     }
39869   }
39870
39871 }
39872
39873
39874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
39875   void * jresult ;
39876   Dali::PanGestureDetector *arg1 = 0 ;
39877   Dali::PanGestureDetector *result = 0 ;
39878
39879   arg1 = (Dali::PanGestureDetector *)jarg1;
39880   if (!arg1) {
39881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
39882     return 0;
39883   }
39884   {
39885     try {
39886       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
39887     } catch (std::out_of_range& e) {
39888       {
39889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39890       };
39891     } catch (std::exception& e) {
39892       {
39893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39894       };
39895     } catch (Dali::DaliException e) {
39896       {
39897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39898       };
39899     } catch (...) {
39900       {
39901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39902       };
39903     }
39904   }
39905
39906   jresult = (void *)result;
39907   return jresult;
39908 }
39909
39910
39911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
39912   void * jresult ;
39913   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
39914   Dali::PanGestureDetector *arg2 = 0 ;
39915   Dali::PanGestureDetector *result = 0 ;
39916
39917   arg1 = (Dali::PanGestureDetector *)jarg1;
39918   arg2 = (Dali::PanGestureDetector *)jarg2;
39919   if (!arg2) {
39920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
39921     return 0;
39922   }
39923   {
39924     try {
39925       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
39926     } catch (std::out_of_range& e) {
39927       {
39928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39929       };
39930     } catch (std::exception& e) {
39931       {
39932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39933       };
39934     } catch (Dali::DaliException e) {
39935       {
39936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39937       };
39938     } catch (...) {
39939       {
39940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39941       };
39942     }
39943   }
39944
39945   jresult = (void *)result;
39946   return jresult;
39947 }
39948
39949
39950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
39951   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
39952   unsigned int arg2 ;
39953
39954   arg1 = (Dali::PanGestureDetector *)jarg1;
39955   arg2 = (unsigned int)jarg2;
39956   {
39957     try {
39958       (arg1)->SetMinimumTouchesRequired(arg2);
39959     } catch (std::out_of_range& e) {
39960       {
39961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39962       };
39963     } catch (std::exception& e) {
39964       {
39965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39966       };
39967     } catch (Dali::DaliException e) {
39968       {
39969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39970       };
39971     } catch (...) {
39972       {
39973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39974       };
39975     }
39976   }
39977
39978 }
39979
39980
39981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
39982   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
39983   unsigned int arg2 ;
39984
39985   arg1 = (Dali::PanGestureDetector *)jarg1;
39986   arg2 = (unsigned int)jarg2;
39987   {
39988     try {
39989       (arg1)->SetMaximumTouchesRequired(arg2);
39990     } catch (std::out_of_range& e) {
39991       {
39992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39993       };
39994     } catch (std::exception& e) {
39995       {
39996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39997       };
39998     } catch (Dali::DaliException e) {
39999       {
40000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40001       };
40002     } catch (...) {
40003       {
40004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40005       };
40006     }
40007   }
40008
40009 }
40010
40011
40012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40013   unsigned int jresult ;
40014   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40015   unsigned int result;
40016
40017   arg1 = (Dali::PanGestureDetector *)jarg1;
40018   {
40019     try {
40020       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40021     } catch (std::out_of_range& e) {
40022       {
40023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40024       };
40025     } catch (std::exception& e) {
40026       {
40027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40028       };
40029     } catch (Dali::DaliException e) {
40030       {
40031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40032       };
40033     } catch (...) {
40034       {
40035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40036       };
40037     }
40038   }
40039
40040   jresult = result;
40041   return jresult;
40042 }
40043
40044
40045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40046   unsigned int jresult ;
40047   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40048   unsigned int result;
40049
40050   arg1 = (Dali::PanGestureDetector *)jarg1;
40051   {
40052     try {
40053       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40054     } catch (std::out_of_range& e) {
40055       {
40056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40057       };
40058     } catch (std::exception& e) {
40059       {
40060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40061       };
40062     } catch (Dali::DaliException e) {
40063       {
40064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40065       };
40066     } catch (...) {
40067       {
40068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40069       };
40070     }
40071   }
40072
40073   jresult = result;
40074   return jresult;
40075 }
40076
40077
40078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40079   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40080   Dali::Radian arg2 ;
40081   Dali::Radian arg3 ;
40082   Dali::Radian *argp2 ;
40083   Dali::Radian *argp3 ;
40084
40085   arg1 = (Dali::PanGestureDetector *)jarg1;
40086   argp2 = (Dali::Radian *)jarg2;
40087   if (!argp2) {
40088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40089     return ;
40090   }
40091   arg2 = *argp2;
40092   argp3 = (Dali::Radian *)jarg3;
40093   if (!argp3) {
40094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40095     return ;
40096   }
40097   arg3 = *argp3;
40098   {
40099     try {
40100       (arg1)->AddAngle(arg2,arg3);
40101     } catch (std::out_of_range& e) {
40102       {
40103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40104       };
40105     } catch (std::exception& e) {
40106       {
40107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40108       };
40109     } catch (Dali::DaliException e) {
40110       {
40111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40112       };
40113     } catch (...) {
40114       {
40115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40116       };
40117     }
40118   }
40119
40120 }
40121
40122
40123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40124   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40125   Dali::Radian arg2 ;
40126   Dali::Radian *argp2 ;
40127
40128   arg1 = (Dali::PanGestureDetector *)jarg1;
40129   argp2 = (Dali::Radian *)jarg2;
40130   if (!argp2) {
40131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40132     return ;
40133   }
40134   arg2 = *argp2;
40135   {
40136     try {
40137       (arg1)->AddAngle(arg2);
40138     } catch (std::out_of_range& e) {
40139       {
40140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40141       };
40142     } catch (std::exception& e) {
40143       {
40144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40145       };
40146     } catch (Dali::DaliException e) {
40147       {
40148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40149       };
40150     } catch (...) {
40151       {
40152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40153       };
40154     }
40155   }
40156
40157 }
40158
40159
40160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40161   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40162   Dali::Radian arg2 ;
40163   Dali::Radian arg3 ;
40164   Dali::Radian *argp2 ;
40165   Dali::Radian *argp3 ;
40166
40167   arg1 = (Dali::PanGestureDetector *)jarg1;
40168   argp2 = (Dali::Radian *)jarg2;
40169   if (!argp2) {
40170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40171     return ;
40172   }
40173   arg2 = *argp2;
40174   argp3 = (Dali::Radian *)jarg3;
40175   if (!argp3) {
40176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40177     return ;
40178   }
40179   arg3 = *argp3;
40180   {
40181     try {
40182       (arg1)->AddDirection(arg2,arg3);
40183     } catch (std::out_of_range& e) {
40184       {
40185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40186       };
40187     } catch (std::exception& e) {
40188       {
40189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40190       };
40191     } catch (Dali::DaliException e) {
40192       {
40193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40194       };
40195     } catch (...) {
40196       {
40197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40198       };
40199     }
40200   }
40201
40202 }
40203
40204
40205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40206   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40207   Dali::Radian arg2 ;
40208   Dali::Radian *argp2 ;
40209
40210   arg1 = (Dali::PanGestureDetector *)jarg1;
40211   argp2 = (Dali::Radian *)jarg2;
40212   if (!argp2) {
40213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40214     return ;
40215   }
40216   arg2 = *argp2;
40217   {
40218     try {
40219       (arg1)->AddDirection(arg2);
40220     } catch (std::out_of_range& e) {
40221       {
40222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40223       };
40224     } catch (std::exception& e) {
40225       {
40226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40227       };
40228     } catch (Dali::DaliException e) {
40229       {
40230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40231       };
40232     } catch (...) {
40233       {
40234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40235       };
40236     }
40237   }
40238
40239 }
40240
40241
40242 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40243   unsigned long jresult ;
40244   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40245   size_t result;
40246
40247   arg1 = (Dali::PanGestureDetector *)jarg1;
40248   {
40249     try {
40250       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
40251     } catch (std::out_of_range& e) {
40252       {
40253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40254       };
40255     } catch (std::exception& e) {
40256       {
40257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40258       };
40259     } catch (Dali::DaliException e) {
40260       {
40261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40262       };
40263     } catch (...) {
40264       {
40265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40266       };
40267     }
40268   }
40269
40270   jresult = (unsigned long)result;
40271   return jresult;
40272 }
40273
40274
40275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
40276   void * jresult ;
40277   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40278   size_t arg2 ;
40279   Dali::PanGestureDetector::AngleThresholdPair result;
40280
40281   arg1 = (Dali::PanGestureDetector *)jarg1;
40282   arg2 = (size_t)jarg2;
40283   {
40284     try {
40285       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
40286     } catch (std::out_of_range& e) {
40287       {
40288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40289       };
40290     } catch (std::exception& e) {
40291       {
40292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40293       };
40294     } catch (Dali::DaliException e) {
40295       {
40296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40297       };
40298     } catch (...) {
40299       {
40300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40301       };
40302     }
40303   }
40304
40305   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
40306   return jresult;
40307 }
40308
40309
40310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
40311   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40312
40313   arg1 = (Dali::PanGestureDetector *)jarg1;
40314   {
40315     try {
40316       (arg1)->ClearAngles();
40317     } catch (std::out_of_range& e) {
40318       {
40319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40320       };
40321     } catch (std::exception& e) {
40322       {
40323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40324       };
40325     } catch (Dali::DaliException e) {
40326       {
40327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40328       };
40329     } catch (...) {
40330       {
40331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40332       };
40333     }
40334   }
40335
40336 }
40337
40338
40339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
40340   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40341   Dali::Radian arg2 ;
40342   Dali::Radian *argp2 ;
40343
40344   arg1 = (Dali::PanGestureDetector *)jarg1;
40345   argp2 = (Dali::Radian *)jarg2;
40346   if (!argp2) {
40347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40348     return ;
40349   }
40350   arg2 = *argp2;
40351   {
40352     try {
40353       (arg1)->RemoveAngle(arg2);
40354     } catch (std::out_of_range& e) {
40355       {
40356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40357       };
40358     } catch (std::exception& e) {
40359       {
40360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40361       };
40362     } catch (Dali::DaliException e) {
40363       {
40364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40365       };
40366     } catch (...) {
40367       {
40368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40369       };
40370     }
40371   }
40372
40373 }
40374
40375
40376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
40377   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40378   Dali::Radian arg2 ;
40379   Dali::Radian *argp2 ;
40380
40381   arg1 = (Dali::PanGestureDetector *)jarg1;
40382   argp2 = (Dali::Radian *)jarg2;
40383   if (!argp2) {
40384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40385     return ;
40386   }
40387   arg2 = *argp2;
40388   {
40389     try {
40390       (arg1)->RemoveDirection(arg2);
40391     } catch (std::out_of_range& e) {
40392       {
40393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40394       };
40395     } catch (std::exception& e) {
40396       {
40397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40398       };
40399     } catch (Dali::DaliException e) {
40400       {
40401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40402       };
40403     } catch (...) {
40404       {
40405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40406       };
40407     }
40408   }
40409
40410 }
40411
40412
40413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
40414   void * jresult ;
40415   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40416   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
40417
40418   arg1 = (Dali::PanGestureDetector *)jarg1;
40419   {
40420     try {
40421       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
40422     } catch (std::out_of_range& e) {
40423       {
40424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40425       };
40426     } catch (std::exception& e) {
40427       {
40428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40429       };
40430     } catch (Dali::DaliException e) {
40431       {
40432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40433       };
40434     } catch (...) {
40435       {
40436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40437       };
40438     }
40439   }
40440
40441   jresult = (void *)result;
40442   return jresult;
40443 }
40444
40445
40446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
40447   Dali::PanGesture *arg1 = 0 ;
40448
40449   arg1 = (Dali::PanGesture *)jarg1;
40450   if (!arg1) {
40451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40452     return ;
40453   }
40454   {
40455     try {
40456       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
40457     } catch (std::out_of_range& e) {
40458       {
40459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40460       };
40461     } catch (std::exception& e) {
40462       {
40463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40464       };
40465     } catch (Dali::DaliException e) {
40466       {
40467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40468       };
40469     } catch (...) {
40470       {
40471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40472       };
40473     }
40474   }
40475
40476 }
40477
40478
40479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
40480   void * jresult ;
40481   Dali::PanGesture *result = 0 ;
40482
40483   {
40484     try {
40485       result = (Dali::PanGesture *)new Dali::PanGesture();
40486     } catch (std::out_of_range& e) {
40487       {
40488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40489       };
40490     } catch (std::exception& e) {
40491       {
40492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40493       };
40494     } catch (Dali::DaliException e) {
40495       {
40496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40497       };
40498     } catch (...) {
40499       {
40500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40501       };
40502     }
40503   }
40504
40505   jresult = (void *)result;
40506   return jresult;
40507 }
40508
40509
40510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
40511   void * jresult ;
40512   Dali::Gesture::State arg1 ;
40513   Dali::PanGesture *result = 0 ;
40514
40515   arg1 = (Dali::Gesture::State)jarg1;
40516   {
40517     try {
40518       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
40519     } catch (std::out_of_range& e) {
40520       {
40521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40522       };
40523     } catch (std::exception& e) {
40524       {
40525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40526       };
40527     } catch (Dali::DaliException e) {
40528       {
40529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40530       };
40531     } catch (...) {
40532       {
40533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40534       };
40535     }
40536   }
40537
40538   jresult = (void *)result;
40539   return jresult;
40540 }
40541
40542
40543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
40544   void * jresult ;
40545   Dali::PanGesture *arg1 = 0 ;
40546   Dali::PanGesture *result = 0 ;
40547
40548   arg1 = (Dali::PanGesture *)jarg1;
40549   if (!arg1) {
40550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40551     return 0;
40552   }
40553   {
40554     try {
40555       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
40556     } catch (std::out_of_range& e) {
40557       {
40558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40559       };
40560     } catch (std::exception& e) {
40561       {
40562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40563       };
40564     } catch (Dali::DaliException e) {
40565       {
40566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40567       };
40568     } catch (...) {
40569       {
40570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40571       };
40572     }
40573   }
40574
40575   jresult = (void *)result;
40576   return jresult;
40577 }
40578
40579
40580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
40581   void * jresult ;
40582   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40583   Dali::PanGesture *arg2 = 0 ;
40584   Dali::PanGesture *result = 0 ;
40585
40586   arg1 = (Dali::PanGesture *)jarg1;
40587   arg2 = (Dali::PanGesture *)jarg2;
40588   if (!arg2) {
40589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40590     return 0;
40591   }
40592   {
40593     try {
40594       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
40595     } catch (std::out_of_range& e) {
40596       {
40597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40598       };
40599     } catch (std::exception& e) {
40600       {
40601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40602       };
40603     } catch (Dali::DaliException e) {
40604       {
40605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40606       };
40607     } catch (...) {
40608       {
40609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40610       };
40611     }
40612   }
40613
40614   jresult = (void *)result;
40615   return jresult;
40616 }
40617
40618
40619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
40620   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40621
40622   arg1 = (Dali::PanGesture *)jarg1;
40623   {
40624     try {
40625       delete arg1;
40626     } catch (std::out_of_range& e) {
40627       {
40628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40629       };
40630     } catch (std::exception& e) {
40631       {
40632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40633       };
40634     } catch (Dali::DaliException e) {
40635       {
40636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40637       };
40638     } catch (...) {
40639       {
40640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40641       };
40642     }
40643   }
40644
40645 }
40646
40647
40648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
40649   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40650   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40651
40652   arg1 = (Dali::PanGesture *)jarg1;
40653   arg2 = (Dali::Vector2 *)jarg2;
40654   if (arg1) (arg1)->velocity = *arg2;
40655 }
40656
40657
40658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
40659   void * jresult ;
40660   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40661   Dali::Vector2 *result = 0 ;
40662
40663   arg1 = (Dali::PanGesture *)jarg1;
40664   result = (Dali::Vector2 *)& ((arg1)->velocity);
40665   jresult = (void *)result;
40666   return jresult;
40667 }
40668
40669
40670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
40671   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40672   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40673
40674   arg1 = (Dali::PanGesture *)jarg1;
40675   arg2 = (Dali::Vector2 *)jarg2;
40676   if (arg1) (arg1)->displacement = *arg2;
40677 }
40678
40679
40680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
40681   void * jresult ;
40682   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40683   Dali::Vector2 *result = 0 ;
40684
40685   arg1 = (Dali::PanGesture *)jarg1;
40686   result = (Dali::Vector2 *)& ((arg1)->displacement);
40687   jresult = (void *)result;
40688   return jresult;
40689 }
40690
40691
40692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
40693   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40694   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40695
40696   arg1 = (Dali::PanGesture *)jarg1;
40697   arg2 = (Dali::Vector2 *)jarg2;
40698   if (arg1) (arg1)->position = *arg2;
40699 }
40700
40701
40702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
40703   void * jresult ;
40704   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40705   Dali::Vector2 *result = 0 ;
40706
40707   arg1 = (Dali::PanGesture *)jarg1;
40708   result = (Dali::Vector2 *)& ((arg1)->position);
40709   jresult = (void *)result;
40710   return jresult;
40711 }
40712
40713
40714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
40715   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40716   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40717
40718   arg1 = (Dali::PanGesture *)jarg1;
40719   arg2 = (Dali::Vector2 *)jarg2;
40720   if (arg1) (arg1)->screenVelocity = *arg2;
40721 }
40722
40723
40724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
40725   void * jresult ;
40726   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40727   Dali::Vector2 *result = 0 ;
40728
40729   arg1 = (Dali::PanGesture *)jarg1;
40730   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
40731   jresult = (void *)result;
40732   return jresult;
40733 }
40734
40735
40736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
40737   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40738   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40739
40740   arg1 = (Dali::PanGesture *)jarg1;
40741   arg2 = (Dali::Vector2 *)jarg2;
40742   if (arg1) (arg1)->screenDisplacement = *arg2;
40743 }
40744
40745
40746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
40747   void * jresult ;
40748   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40749   Dali::Vector2 *result = 0 ;
40750
40751   arg1 = (Dali::PanGesture *)jarg1;
40752   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
40753   jresult = (void *)result;
40754   return jresult;
40755 }
40756
40757
40758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
40759   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40760   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40761
40762   arg1 = (Dali::PanGesture *)jarg1;
40763   arg2 = (Dali::Vector2 *)jarg2;
40764   if (arg1) (arg1)->screenPosition = *arg2;
40765 }
40766
40767
40768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
40769   void * jresult ;
40770   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40771   Dali::Vector2 *result = 0 ;
40772
40773   arg1 = (Dali::PanGesture *)jarg1;
40774   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
40775   jresult = (void *)result;
40776   return jresult;
40777 }
40778
40779
40780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
40781   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40782   unsigned int arg2 ;
40783
40784   arg1 = (Dali::PanGesture *)jarg1;
40785   arg2 = (unsigned int)jarg2;
40786   if (arg1) (arg1)->numberOfTouches = arg2;
40787 }
40788
40789
40790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
40791   unsigned int jresult ;
40792   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40793   unsigned int result;
40794
40795   arg1 = (Dali::PanGesture *)jarg1;
40796   result = (unsigned int) ((arg1)->numberOfTouches);
40797   jresult = result;
40798   return jresult;
40799 }
40800
40801
40802 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
40803   float jresult ;
40804   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40805   float result;
40806
40807   arg1 = (Dali::PanGesture *)jarg1;
40808   {
40809     try {
40810       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
40811     } catch (std::out_of_range& e) {
40812       {
40813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40814       };
40815     } catch (std::exception& e) {
40816       {
40817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40818       };
40819     } catch (Dali::DaliException e) {
40820       {
40821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40822       };
40823     } catch (...) {
40824       {
40825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40826       };
40827     }
40828   }
40829
40830   jresult = result;
40831   return jresult;
40832 }
40833
40834
40835 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
40836   float jresult ;
40837   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40838   float result;
40839
40840   arg1 = (Dali::PanGesture *)jarg1;
40841   {
40842     try {
40843       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
40844     } catch (std::out_of_range& e) {
40845       {
40846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40847       };
40848     } catch (std::exception& e) {
40849       {
40850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40851       };
40852     } catch (Dali::DaliException e) {
40853       {
40854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40855       };
40856     } catch (...) {
40857       {
40858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40859       };
40860     }
40861   }
40862
40863   jresult = result;
40864   return jresult;
40865 }
40866
40867
40868 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
40869   float jresult ;
40870   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40871   float result;
40872
40873   arg1 = (Dali::PanGesture *)jarg1;
40874   {
40875     try {
40876       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
40877     } catch (std::out_of_range& e) {
40878       {
40879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40880       };
40881     } catch (std::exception& e) {
40882       {
40883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40884       };
40885     } catch (Dali::DaliException e) {
40886       {
40887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40888       };
40889     } catch (...) {
40890       {
40891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40892       };
40893     }
40894   }
40895
40896   jresult = result;
40897   return jresult;
40898 }
40899
40900
40901 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
40902   float jresult ;
40903   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40904   float result;
40905
40906   arg1 = (Dali::PanGesture *)jarg1;
40907   {
40908     try {
40909       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
40910     } catch (std::out_of_range& e) {
40911       {
40912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40913       };
40914     } catch (std::exception& e) {
40915       {
40916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40917       };
40918     } catch (Dali::DaliException e) {
40919       {
40920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40921       };
40922     } catch (...) {
40923       {
40924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40925       };
40926     }
40927   }
40928
40929   jresult = result;
40930   return jresult;
40931 }
40932
40933
40934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
40935   void * jresult ;
40936   Dali::PinchGestureDetector *result = 0 ;
40937
40938   {
40939     try {
40940       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
40941     } catch (std::out_of_range& e) {
40942       {
40943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40944       };
40945     } catch (std::exception& e) {
40946       {
40947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40948       };
40949     } catch (Dali::DaliException e) {
40950       {
40951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40952       };
40953     } catch (...) {
40954       {
40955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40956       };
40957     }
40958   }
40959
40960   jresult = (void *)result;
40961   return jresult;
40962 }
40963
40964
40965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
40966   void * jresult ;
40967   Dali::PinchGestureDetector result;
40968
40969   {
40970     try {
40971       result = Dali::PinchGestureDetector::New();
40972     } catch (std::out_of_range& e) {
40973       {
40974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40975       };
40976     } catch (std::exception& e) {
40977       {
40978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40979       };
40980     } catch (Dali::DaliException e) {
40981       {
40982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40983       };
40984     } catch (...) {
40985       {
40986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40987       };
40988     }
40989   }
40990
40991   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
40992   return jresult;
40993 }
40994
40995
40996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
40997   void * jresult ;
40998   Dali::BaseHandle arg1 ;
40999   Dali::BaseHandle *argp1 ;
41000   Dali::PinchGestureDetector result;
41001
41002   argp1 = (Dali::BaseHandle *)jarg1;
41003   if (!argp1) {
41004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41005     return 0;
41006   }
41007   arg1 = *argp1;
41008   {
41009     try {
41010       result = Dali::PinchGestureDetector::DownCast(arg1);
41011     } catch (std::out_of_range& e) {
41012       {
41013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41014       };
41015     } catch (std::exception& e) {
41016       {
41017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41018       };
41019     } catch (Dali::DaliException e) {
41020       {
41021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41022       };
41023     } catch (...) {
41024       {
41025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41026       };
41027     }
41028   }
41029
41030   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41031   return jresult;
41032 }
41033
41034
41035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41036   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41037
41038   arg1 = (Dali::PinchGestureDetector *)jarg1;
41039   {
41040     try {
41041       delete arg1;
41042     } catch (std::out_of_range& e) {
41043       {
41044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41045       };
41046     } catch (std::exception& e) {
41047       {
41048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41049       };
41050     } catch (Dali::DaliException e) {
41051       {
41052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41053       };
41054     } catch (...) {
41055       {
41056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41057       };
41058     }
41059   }
41060
41061 }
41062
41063
41064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41065   void * jresult ;
41066   Dali::PinchGestureDetector *arg1 = 0 ;
41067   Dali::PinchGestureDetector *result = 0 ;
41068
41069   arg1 = (Dali::PinchGestureDetector *)jarg1;
41070   if (!arg1) {
41071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41072     return 0;
41073   }
41074   {
41075     try {
41076       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41077     } catch (std::out_of_range& e) {
41078       {
41079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41080       };
41081     } catch (std::exception& e) {
41082       {
41083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41084       };
41085     } catch (Dali::DaliException e) {
41086       {
41087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41088       };
41089     } catch (...) {
41090       {
41091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41092       };
41093     }
41094   }
41095
41096   jresult = (void *)result;
41097   return jresult;
41098 }
41099
41100
41101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41102   void * jresult ;
41103   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41104   Dali::PinchGestureDetector *arg2 = 0 ;
41105   Dali::PinchGestureDetector *result = 0 ;
41106
41107   arg1 = (Dali::PinchGestureDetector *)jarg1;
41108   arg2 = (Dali::PinchGestureDetector *)jarg2;
41109   if (!arg2) {
41110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41111     return 0;
41112   }
41113   {
41114     try {
41115       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41116     } catch (std::out_of_range& e) {
41117       {
41118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41119       };
41120     } catch (std::exception& e) {
41121       {
41122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41123       };
41124     } catch (Dali::DaliException e) {
41125       {
41126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41127       };
41128     } catch (...) {
41129       {
41130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41131       };
41132     }
41133   }
41134
41135   jresult = (void *)result;
41136   return jresult;
41137 }
41138
41139
41140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41141   void * jresult ;
41142   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41143   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41144
41145   arg1 = (Dali::PinchGestureDetector *)jarg1;
41146   {
41147     try {
41148       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41149     } catch (std::out_of_range& e) {
41150       {
41151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41152       };
41153     } catch (std::exception& e) {
41154       {
41155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41156       };
41157     } catch (Dali::DaliException e) {
41158       {
41159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41160       };
41161     } catch (...) {
41162       {
41163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41164       };
41165     }
41166   }
41167
41168   jresult = (void *)result;
41169   return jresult;
41170 }
41171
41172
41173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41174   void * jresult ;
41175   Dali::Gesture::State arg1 ;
41176   Dali::PinchGesture *result = 0 ;
41177
41178   arg1 = (Dali::Gesture::State)jarg1;
41179   {
41180     try {
41181       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41182     } catch (std::out_of_range& e) {
41183       {
41184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41185       };
41186     } catch (std::exception& e) {
41187       {
41188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41189       };
41190     } catch (Dali::DaliException e) {
41191       {
41192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41193       };
41194     } catch (...) {
41195       {
41196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41197       };
41198     }
41199   }
41200
41201   jresult = (void *)result;
41202   return jresult;
41203 }
41204
41205
41206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41207   void * jresult ;
41208   Dali::PinchGesture *arg1 = 0 ;
41209   Dali::PinchGesture *result = 0 ;
41210
41211   arg1 = (Dali::PinchGesture *)jarg1;
41212   if (!arg1) {
41213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41214     return 0;
41215   }
41216   {
41217     try {
41218       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41219     } catch (std::out_of_range& e) {
41220       {
41221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41222       };
41223     } catch (std::exception& e) {
41224       {
41225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41226       };
41227     } catch (Dali::DaliException e) {
41228       {
41229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41230       };
41231     } catch (...) {
41232       {
41233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41234       };
41235     }
41236   }
41237
41238   jresult = (void *)result;
41239   return jresult;
41240 }
41241
41242
41243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
41244   void * jresult ;
41245   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41246   Dali::PinchGesture *arg2 = 0 ;
41247   Dali::PinchGesture *result = 0 ;
41248
41249   arg1 = (Dali::PinchGesture *)jarg1;
41250   arg2 = (Dali::PinchGesture *)jarg2;
41251   if (!arg2) {
41252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41253     return 0;
41254   }
41255   {
41256     try {
41257       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
41258     } catch (std::out_of_range& e) {
41259       {
41260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41261       };
41262     } catch (std::exception& e) {
41263       {
41264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41265       };
41266     } catch (Dali::DaliException e) {
41267       {
41268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41269       };
41270     } catch (...) {
41271       {
41272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41273       };
41274     }
41275   }
41276
41277   jresult = (void *)result;
41278   return jresult;
41279 }
41280
41281
41282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
41283   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41284
41285   arg1 = (Dali::PinchGesture *)jarg1;
41286   {
41287     try {
41288       delete arg1;
41289     } catch (std::out_of_range& e) {
41290       {
41291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41292       };
41293     } catch (std::exception& e) {
41294       {
41295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41296       };
41297     } catch (Dali::DaliException e) {
41298       {
41299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41300       };
41301     } catch (...) {
41302       {
41303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41304       };
41305     }
41306   }
41307
41308 }
41309
41310
41311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
41312   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41313   float arg2 ;
41314
41315   arg1 = (Dali::PinchGesture *)jarg1;
41316   arg2 = (float)jarg2;
41317   if (arg1) (arg1)->scale = arg2;
41318 }
41319
41320
41321 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
41322   float jresult ;
41323   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41324   float result;
41325
41326   arg1 = (Dali::PinchGesture *)jarg1;
41327   result = (float) ((arg1)->scale);
41328   jresult = result;
41329   return jresult;
41330 }
41331
41332
41333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
41334   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41335   float arg2 ;
41336
41337   arg1 = (Dali::PinchGesture *)jarg1;
41338   arg2 = (float)jarg2;
41339   if (arg1) (arg1)->speed = arg2;
41340 }
41341
41342
41343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
41344   float jresult ;
41345   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41346   float result;
41347
41348   arg1 = (Dali::PinchGesture *)jarg1;
41349   result = (float) ((arg1)->speed);
41350   jresult = result;
41351   return jresult;
41352 }
41353
41354
41355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
41356   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41357   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41358
41359   arg1 = (Dali::PinchGesture *)jarg1;
41360   arg2 = (Dali::Vector2 *)jarg2;
41361   if (arg1) (arg1)->screenCenterPoint = *arg2;
41362 }
41363
41364
41365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
41366   void * jresult ;
41367   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41368   Dali::Vector2 *result = 0 ;
41369
41370   arg1 = (Dali::PinchGesture *)jarg1;
41371   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
41372   jresult = (void *)result;
41373   return jresult;
41374 }
41375
41376
41377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
41378   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41379   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41380
41381   arg1 = (Dali::PinchGesture *)jarg1;
41382   arg2 = (Dali::Vector2 *)jarg2;
41383   if (arg1) (arg1)->localCenterPoint = *arg2;
41384 }
41385
41386
41387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
41388   void * jresult ;
41389   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41390   Dali::Vector2 *result = 0 ;
41391
41392   arg1 = (Dali::PinchGesture *)jarg1;
41393   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
41394   jresult = (void *)result;
41395   return jresult;
41396 }
41397
41398
41399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
41400   void * jresult ;
41401   Dali::TapGestureDetector *result = 0 ;
41402
41403   {
41404     try {
41405       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
41406     } catch (std::out_of_range& e) {
41407       {
41408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41409       };
41410     } catch (std::exception& e) {
41411       {
41412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41413       };
41414     } catch (Dali::DaliException e) {
41415       {
41416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41417       };
41418     } catch (...) {
41419       {
41420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41421       };
41422     }
41423   }
41424
41425   jresult = (void *)result;
41426   return jresult;
41427 }
41428
41429
41430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
41431   void * jresult ;
41432   Dali::TapGestureDetector result;
41433
41434   {
41435     try {
41436       result = Dali::TapGestureDetector::New();
41437     } catch (std::out_of_range& e) {
41438       {
41439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41440       };
41441     } catch (std::exception& e) {
41442       {
41443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41444       };
41445     } catch (Dali::DaliException e) {
41446       {
41447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41448       };
41449     } catch (...) {
41450       {
41451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41452       };
41453     }
41454   }
41455
41456   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41457   return jresult;
41458 }
41459
41460
41461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
41462   void * jresult ;
41463   unsigned int arg1 ;
41464   Dali::TapGestureDetector result;
41465
41466   arg1 = (unsigned int)jarg1;
41467   {
41468     try {
41469       result = Dali::TapGestureDetector::New(arg1);
41470     } catch (std::out_of_range& e) {
41471       {
41472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41473       };
41474     } catch (std::exception& e) {
41475       {
41476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41477       };
41478     } catch (Dali::DaliException e) {
41479       {
41480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41481       };
41482     } catch (...) {
41483       {
41484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41485       };
41486     }
41487   }
41488
41489   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41490   return jresult;
41491 }
41492
41493
41494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
41495   void * jresult ;
41496   Dali::BaseHandle arg1 ;
41497   Dali::BaseHandle *argp1 ;
41498   Dali::TapGestureDetector result;
41499
41500   argp1 = (Dali::BaseHandle *)jarg1;
41501   if (!argp1) {
41502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41503     return 0;
41504   }
41505   arg1 = *argp1;
41506   {
41507     try {
41508       result = Dali::TapGestureDetector::DownCast(arg1);
41509     } catch (std::out_of_range& e) {
41510       {
41511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41512       };
41513     } catch (std::exception& e) {
41514       {
41515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41516       };
41517     } catch (Dali::DaliException e) {
41518       {
41519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41520       };
41521     } catch (...) {
41522       {
41523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41524       };
41525     }
41526   }
41527
41528   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41529   return jresult;
41530 }
41531
41532
41533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
41534   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41535
41536   arg1 = (Dali::TapGestureDetector *)jarg1;
41537   {
41538     try {
41539       delete arg1;
41540     } catch (std::out_of_range& e) {
41541       {
41542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41543       };
41544     } catch (std::exception& e) {
41545       {
41546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41547       };
41548     } catch (Dali::DaliException e) {
41549       {
41550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41551       };
41552     } catch (...) {
41553       {
41554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41555       };
41556     }
41557   }
41558
41559 }
41560
41561
41562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
41563   void * jresult ;
41564   Dali::TapGestureDetector *arg1 = 0 ;
41565   Dali::TapGestureDetector *result = 0 ;
41566
41567   arg1 = (Dali::TapGestureDetector *)jarg1;
41568   if (!arg1) {
41569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41570     return 0;
41571   }
41572   {
41573     try {
41574       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
41575     } catch (std::out_of_range& e) {
41576       {
41577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41578       };
41579     } catch (std::exception& e) {
41580       {
41581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41582       };
41583     } catch (Dali::DaliException e) {
41584       {
41585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41586       };
41587     } catch (...) {
41588       {
41589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41590       };
41591     }
41592   }
41593
41594   jresult = (void *)result;
41595   return jresult;
41596 }
41597
41598
41599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
41600   void * jresult ;
41601   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41602   Dali::TapGestureDetector *arg2 = 0 ;
41603   Dali::TapGestureDetector *result = 0 ;
41604
41605   arg1 = (Dali::TapGestureDetector *)jarg1;
41606   arg2 = (Dali::TapGestureDetector *)jarg2;
41607   if (!arg2) {
41608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41609     return 0;
41610   }
41611   {
41612     try {
41613       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
41614     } catch (std::out_of_range& e) {
41615       {
41616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41617       };
41618     } catch (std::exception& e) {
41619       {
41620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41621       };
41622     } catch (Dali::DaliException e) {
41623       {
41624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41625       };
41626     } catch (...) {
41627       {
41628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41629       };
41630     }
41631   }
41632
41633   jresult = (void *)result;
41634   return jresult;
41635 }
41636
41637
41638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
41639   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41640   unsigned int arg2 ;
41641
41642   arg1 = (Dali::TapGestureDetector *)jarg1;
41643   arg2 = (unsigned int)jarg2;
41644   {
41645     try {
41646       (arg1)->SetMinimumTapsRequired(arg2);
41647     } catch (std::out_of_range& e) {
41648       {
41649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41650       };
41651     } catch (std::exception& e) {
41652       {
41653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41654       };
41655     } catch (Dali::DaliException e) {
41656       {
41657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41658       };
41659     } catch (...) {
41660       {
41661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41662       };
41663     }
41664   }
41665
41666 }
41667
41668
41669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
41670   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41671   unsigned int arg2 ;
41672
41673   arg1 = (Dali::TapGestureDetector *)jarg1;
41674   arg2 = (unsigned int)jarg2;
41675   {
41676     try {
41677       (arg1)->SetMaximumTapsRequired(arg2);
41678     } catch (std::out_of_range& e) {
41679       {
41680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41681       };
41682     } catch (std::exception& e) {
41683       {
41684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41685       };
41686     } catch (Dali::DaliException e) {
41687       {
41688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41689       };
41690     } catch (...) {
41691       {
41692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41693       };
41694     }
41695   }
41696
41697 }
41698
41699
41700 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
41701   unsigned int jresult ;
41702   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41703   unsigned int result;
41704
41705   arg1 = (Dali::TapGestureDetector *)jarg1;
41706   {
41707     try {
41708       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
41709     } catch (std::out_of_range& e) {
41710       {
41711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41712       };
41713     } catch (std::exception& e) {
41714       {
41715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41716       };
41717     } catch (Dali::DaliException e) {
41718       {
41719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41720       };
41721     } catch (...) {
41722       {
41723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41724       };
41725     }
41726   }
41727
41728   jresult = result;
41729   return jresult;
41730 }
41731
41732
41733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
41734   unsigned int jresult ;
41735   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41736   unsigned int result;
41737
41738   arg1 = (Dali::TapGestureDetector *)jarg1;
41739   {
41740     try {
41741       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
41742     } catch (std::out_of_range& e) {
41743       {
41744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41745       };
41746     } catch (std::exception& e) {
41747       {
41748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41749       };
41750     } catch (Dali::DaliException e) {
41751       {
41752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41753       };
41754     } catch (...) {
41755       {
41756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41757       };
41758     }
41759   }
41760
41761   jresult = result;
41762   return jresult;
41763 }
41764
41765
41766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
41767   void * jresult ;
41768   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41769   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
41770
41771   arg1 = (Dali::TapGestureDetector *)jarg1;
41772   {
41773     try {
41774       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41775     } catch (std::out_of_range& e) {
41776       {
41777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41778       };
41779     } catch (std::exception& e) {
41780       {
41781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41782       };
41783     } catch (Dali::DaliException e) {
41784       {
41785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41786       };
41787     } catch (...) {
41788       {
41789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41790       };
41791     }
41792   }
41793
41794   jresult = (void *)result;
41795   return jresult;
41796 }
41797
41798
41799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
41800   void * jresult ;
41801   Dali::TapGesture *result = 0 ;
41802
41803   {
41804     try {
41805       result = (Dali::TapGesture *)new Dali::TapGesture();
41806     } catch (std::out_of_range& e) {
41807       {
41808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41809       };
41810     } catch (std::exception& e) {
41811       {
41812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41813       };
41814     } catch (Dali::DaliException e) {
41815       {
41816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41817       };
41818     } catch (...) {
41819       {
41820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41821       };
41822     }
41823   }
41824
41825   jresult = (void *)result;
41826   return jresult;
41827 }
41828
41829
41830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
41831   void * jresult ;
41832   Dali::TapGesture *arg1 = 0 ;
41833   Dali::TapGesture *result = 0 ;
41834
41835   arg1 = (Dali::TapGesture *)jarg1;
41836   if (!arg1) {
41837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
41838     return 0;
41839   }
41840   {
41841     try {
41842       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
41843     } catch (std::out_of_range& e) {
41844       {
41845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41846       };
41847     } catch (std::exception& e) {
41848       {
41849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41850       };
41851     } catch (Dali::DaliException e) {
41852       {
41853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41854       };
41855     } catch (...) {
41856       {
41857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41858       };
41859     }
41860   }
41861
41862   jresult = (void *)result;
41863   return jresult;
41864 }
41865
41866
41867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
41868   void * jresult ;
41869   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41870   Dali::TapGesture *arg2 = 0 ;
41871   Dali::TapGesture *result = 0 ;
41872
41873   arg1 = (Dali::TapGesture *)jarg1;
41874   arg2 = (Dali::TapGesture *)jarg2;
41875   if (!arg2) {
41876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
41877     return 0;
41878   }
41879   {
41880     try {
41881       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
41882     } catch (std::out_of_range& e) {
41883       {
41884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41885       };
41886     } catch (std::exception& e) {
41887       {
41888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41889       };
41890     } catch (Dali::DaliException e) {
41891       {
41892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41893       };
41894     } catch (...) {
41895       {
41896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41897       };
41898     }
41899   }
41900
41901   jresult = (void *)result;
41902   return jresult;
41903 }
41904
41905
41906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
41907   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41908
41909   arg1 = (Dali::TapGesture *)jarg1;
41910   {
41911     try {
41912       delete arg1;
41913     } catch (std::out_of_range& e) {
41914       {
41915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41916       };
41917     } catch (std::exception& e) {
41918       {
41919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41920       };
41921     } catch (Dali::DaliException e) {
41922       {
41923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41924       };
41925     } catch (...) {
41926       {
41927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41928       };
41929     }
41930   }
41931
41932 }
41933
41934
41935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
41936   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41937   unsigned int arg2 ;
41938
41939   arg1 = (Dali::TapGesture *)jarg1;
41940   arg2 = (unsigned int)jarg2;
41941   if (arg1) (arg1)->numberOfTaps = arg2;
41942 }
41943
41944
41945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
41946   unsigned int jresult ;
41947   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41948   unsigned int result;
41949
41950   arg1 = (Dali::TapGesture *)jarg1;
41951   result = (unsigned int) ((arg1)->numberOfTaps);
41952   jresult = result;
41953   return jresult;
41954 }
41955
41956
41957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41958   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41959   unsigned int arg2 ;
41960
41961   arg1 = (Dali::TapGesture *)jarg1;
41962   arg2 = (unsigned int)jarg2;
41963   if (arg1) (arg1)->numberOfTouches = arg2;
41964 }
41965
41966
41967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
41968   unsigned int jresult ;
41969   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41970   unsigned int result;
41971
41972   arg1 = (Dali::TapGesture *)jarg1;
41973   result = (unsigned int) ((arg1)->numberOfTouches);
41974   jresult = result;
41975   return jresult;
41976 }
41977
41978
41979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
41980   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41981   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41982
41983   arg1 = (Dali::TapGesture *)jarg1;
41984   arg2 = (Dali::Vector2 *)jarg2;
41985   if (arg1) (arg1)->screenPoint = *arg2;
41986 }
41987
41988
41989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
41990   void * jresult ;
41991   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41992   Dali::Vector2 *result = 0 ;
41993
41994   arg1 = (Dali::TapGesture *)jarg1;
41995   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
41996   jresult = (void *)result;
41997   return jresult;
41998 }
41999
42000
42001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42002   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42003   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42004
42005   arg1 = (Dali::TapGesture *)jarg1;
42006   arg2 = (Dali::Vector2 *)jarg2;
42007   if (arg1) (arg1)->localPoint = *arg2;
42008 }
42009
42010
42011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42012   void * jresult ;
42013   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42014   Dali::Vector2 *result = 0 ;
42015
42016   arg1 = (Dali::TapGesture *)jarg1;
42017   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42018   jresult = (void *)result;
42019   return jresult;
42020 }
42021
42022
42023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42024   void * jresult ;
42025   Dali::AlphaFunction *result = 0 ;
42026
42027   {
42028     try {
42029       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42030     } catch (std::out_of_range& e) {
42031       {
42032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42033       };
42034     } catch (std::exception& e) {
42035       {
42036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42037       };
42038     } catch (Dali::DaliException e) {
42039       {
42040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42041       };
42042     } catch (...) {
42043       {
42044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42045       };
42046     }
42047   }
42048
42049   jresult = (void *)result;
42050   return jresult;
42051 }
42052
42053
42054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42055   void * jresult ;
42056   Dali::AlphaFunction::BuiltinFunction arg1 ;
42057   Dali::AlphaFunction *result = 0 ;
42058
42059   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42060   {
42061     try {
42062       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42063     } catch (std::out_of_range& e) {
42064       {
42065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42066       };
42067     } catch (std::exception& e) {
42068       {
42069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42070       };
42071     } catch (Dali::DaliException e) {
42072       {
42073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42074       };
42075     } catch (...) {
42076       {
42077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42078       };
42079     }
42080   }
42081
42082   jresult = (void *)result;
42083   return jresult;
42084 }
42085
42086
42087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42088   void * jresult ;
42089   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42090   Dali::AlphaFunction *result = 0 ;
42091
42092   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42093   {
42094     try {
42095       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42096     } catch (std::out_of_range& e) {
42097       {
42098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42099       };
42100     } catch (std::exception& e) {
42101       {
42102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42103       };
42104     } catch (Dali::DaliException e) {
42105       {
42106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42107       };
42108     } catch (...) {
42109       {
42110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42111       };
42112     }
42113   }
42114
42115   jresult = (void *)result;
42116   return jresult;
42117 }
42118
42119
42120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42121   void * jresult ;
42122   Dali::Vector2 *arg1 = 0 ;
42123   Dali::Vector2 *arg2 = 0 ;
42124   Dali::AlphaFunction *result = 0 ;
42125
42126   arg1 = (Dali::Vector2 *)jarg1;
42127   if (!arg1) {
42128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42129     return 0;
42130   }
42131   arg2 = (Dali::Vector2 *)jarg2;
42132   if (!arg2) {
42133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42134     return 0;
42135   }
42136   {
42137     try {
42138       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42139     } catch (std::out_of_range& e) {
42140       {
42141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42142       };
42143     } catch (std::exception& e) {
42144       {
42145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42146       };
42147     } catch (Dali::DaliException e) {
42148       {
42149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42150       };
42151     } catch (...) {
42152       {
42153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42154       };
42155     }
42156   }
42157
42158   jresult = (void *)result;
42159   return jresult;
42160 }
42161
42162
42163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42164   void * jresult ;
42165   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42166   Dali::Vector4 result;
42167
42168   arg1 = (Dali::AlphaFunction *)jarg1;
42169   {
42170     try {
42171       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42172     } catch (std::out_of_range& e) {
42173       {
42174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42175       };
42176     } catch (std::exception& e) {
42177       {
42178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42179       };
42180     } catch (Dali::DaliException e) {
42181       {
42182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42183       };
42184     } catch (...) {
42185       {
42186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42187       };
42188     }
42189   }
42190
42191   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42192   return jresult;
42193 }
42194
42195
42196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42197   void * jresult ;
42198   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42199   Dali::AlphaFunctionPrototype result;
42200
42201   arg1 = (Dali::AlphaFunction *)jarg1;
42202   {
42203     try {
42204       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42205     } catch (std::out_of_range& e) {
42206       {
42207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42208       };
42209     } catch (std::exception& e) {
42210       {
42211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42212       };
42213     } catch (Dali::DaliException e) {
42214       {
42215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42216       };
42217     } catch (...) {
42218       {
42219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42220       };
42221     }
42222   }
42223
42224   jresult = (void *)result;
42225   return jresult;
42226 }
42227
42228
42229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42230   int jresult ;
42231   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42232   Dali::AlphaFunction::BuiltinFunction result;
42233
42234   arg1 = (Dali::AlphaFunction *)jarg1;
42235   {
42236     try {
42237       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
42238     } catch (std::out_of_range& e) {
42239       {
42240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42241       };
42242     } catch (std::exception& e) {
42243       {
42244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42245       };
42246     } catch (Dali::DaliException e) {
42247       {
42248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42249       };
42250     } catch (...) {
42251       {
42252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42253       };
42254     }
42255   }
42256
42257   jresult = (int)result;
42258   return jresult;
42259 }
42260
42261
42262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
42263   int jresult ;
42264   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42265   Dali::AlphaFunction::Mode result;
42266
42267   arg1 = (Dali::AlphaFunction *)jarg1;
42268   {
42269     try {
42270       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
42271     } catch (std::out_of_range& e) {
42272       {
42273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42274       };
42275     } catch (std::exception& e) {
42276       {
42277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42278       };
42279     } catch (Dali::DaliException e) {
42280       {
42281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42282       };
42283     } catch (...) {
42284       {
42285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42286       };
42287     }
42288   }
42289
42290   jresult = (int)result;
42291   return jresult;
42292 }
42293
42294
42295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
42296   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42297
42298   arg1 = (Dali::AlphaFunction *)jarg1;
42299   {
42300     try {
42301       delete arg1;
42302     } catch (std::out_of_range& e) {
42303       {
42304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42305       };
42306     } catch (std::exception& e) {
42307       {
42308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42309       };
42310     } catch (Dali::DaliException e) {
42311       {
42312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42313       };
42314     } catch (...) {
42315       {
42316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42317       };
42318     }
42319   }
42320
42321 }
42322
42323
42324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
42325   void * jresult ;
42326   Dali::KeyFrames result;
42327
42328   {
42329     try {
42330       result = Dali::KeyFrames::New();
42331     } catch (std::out_of_range& e) {
42332       {
42333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42334       };
42335     } catch (std::exception& e) {
42336       {
42337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42338       };
42339     } catch (Dali::DaliException e) {
42340       {
42341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42342       };
42343     } catch (...) {
42344       {
42345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42346       };
42347     }
42348   }
42349
42350   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42351   return jresult;
42352 }
42353
42354
42355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
42356   void * jresult ;
42357   Dali::BaseHandle arg1 ;
42358   Dali::BaseHandle *argp1 ;
42359   Dali::KeyFrames result;
42360
42361   argp1 = (Dali::BaseHandle *)jarg1;
42362   if (!argp1) {
42363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42364     return 0;
42365   }
42366   arg1 = *argp1;
42367   {
42368     try {
42369       result = Dali::KeyFrames::DownCast(arg1);
42370     } catch (std::out_of_range& e) {
42371       {
42372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42373       };
42374     } catch (std::exception& e) {
42375       {
42376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42377       };
42378     } catch (Dali::DaliException e) {
42379       {
42380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42381       };
42382     } catch (...) {
42383       {
42384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42385       };
42386     }
42387   }
42388
42389   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42390   return jresult;
42391 }
42392
42393
42394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
42395   void * jresult ;
42396   Dali::KeyFrames *result = 0 ;
42397
42398   {
42399     try {
42400       result = (Dali::KeyFrames *)new Dali::KeyFrames();
42401     } catch (std::out_of_range& e) {
42402       {
42403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42404       };
42405     } catch (std::exception& e) {
42406       {
42407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42408       };
42409     } catch (Dali::DaliException e) {
42410       {
42411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42412       };
42413     } catch (...) {
42414       {
42415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42416       };
42417     }
42418   }
42419
42420   jresult = (void *)result;
42421   return jresult;
42422 }
42423
42424
42425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
42426   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42427
42428   arg1 = (Dali::KeyFrames *)jarg1;
42429   {
42430     try {
42431       delete arg1;
42432     } catch (std::out_of_range& e) {
42433       {
42434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42435       };
42436     } catch (std::exception& e) {
42437       {
42438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42439       };
42440     } catch (Dali::DaliException e) {
42441       {
42442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42443       };
42444     } catch (...) {
42445       {
42446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42447       };
42448     }
42449   }
42450
42451 }
42452
42453
42454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
42455   void * jresult ;
42456   Dali::KeyFrames *arg1 = 0 ;
42457   Dali::KeyFrames *result = 0 ;
42458
42459   arg1 = (Dali::KeyFrames *)jarg1;
42460   if (!arg1) {
42461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42462     return 0;
42463   }
42464   {
42465     try {
42466       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
42467     } catch (std::out_of_range& e) {
42468       {
42469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42470       };
42471     } catch (std::exception& e) {
42472       {
42473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42474       };
42475     } catch (Dali::DaliException e) {
42476       {
42477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42478       };
42479     } catch (...) {
42480       {
42481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42482       };
42483     }
42484   }
42485
42486   jresult = (void *)result;
42487   return jresult;
42488 }
42489
42490
42491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
42492   void * jresult ;
42493   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42494   Dali::KeyFrames *arg2 = 0 ;
42495   Dali::KeyFrames *result = 0 ;
42496
42497   arg1 = (Dali::KeyFrames *)jarg1;
42498   arg2 = (Dali::KeyFrames *)jarg2;
42499   if (!arg2) {
42500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42501     return 0;
42502   }
42503   {
42504     try {
42505       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
42506     } catch (std::out_of_range& e) {
42507       {
42508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42509       };
42510     } catch (std::exception& e) {
42511       {
42512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42513       };
42514     } catch (Dali::DaliException e) {
42515       {
42516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42517       };
42518     } catch (...) {
42519       {
42520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42521       };
42522     }
42523   }
42524
42525   jresult = (void *)result;
42526   return jresult;
42527 }
42528
42529
42530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
42531   int jresult ;
42532   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42533   Dali::Property::Type result;
42534
42535   arg1 = (Dali::KeyFrames *)jarg1;
42536   {
42537     try {
42538       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
42539     } catch (std::out_of_range& e) {
42540       {
42541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42542       };
42543     } catch (std::exception& e) {
42544       {
42545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42546       };
42547     } catch (Dali::DaliException e) {
42548       {
42549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42550       };
42551     } catch (...) {
42552       {
42553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42554       };
42555     }
42556   }
42557
42558   jresult = (int)result;
42559   return jresult;
42560 }
42561
42562
42563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
42564   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42565   float arg2 ;
42566   Dali::Property::Value arg3 ;
42567   Dali::Property::Value *argp3 ;
42568
42569   arg1 = (Dali::KeyFrames *)jarg1;
42570   arg2 = (float)jarg2;
42571   argp3 = (Dali::Property::Value *)jarg3;
42572   if (!argp3) {
42573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42574     return ;
42575   }
42576   arg3 = *argp3;
42577   {
42578     try {
42579       (arg1)->Add(arg2,arg3);
42580     } catch (std::out_of_range& e) {
42581       {
42582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42583       };
42584     } catch (std::exception& e) {
42585       {
42586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42587       };
42588     } catch (Dali::DaliException e) {
42589       {
42590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42591       };
42592     } catch (...) {
42593       {
42594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42595       };
42596     }
42597   }
42598
42599 }
42600
42601
42602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
42603   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42604   float arg2 ;
42605   Dali::Property::Value arg3 ;
42606   Dali::AlphaFunction arg4 ;
42607   Dali::Property::Value *argp3 ;
42608   Dali::AlphaFunction *argp4 ;
42609
42610   arg1 = (Dali::KeyFrames *)jarg1;
42611   arg2 = (float)jarg2;
42612   argp3 = (Dali::Property::Value *)jarg3;
42613   if (!argp3) {
42614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42615     return ;
42616   }
42617   arg3 = *argp3;
42618   argp4 = (Dali::AlphaFunction *)jarg4;
42619   if (!argp4) {
42620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
42621     return ;
42622   }
42623   arg4 = *argp4;
42624   {
42625     try {
42626       (arg1)->Add(arg2,arg3,arg4);
42627     } catch (std::out_of_range& e) {
42628       {
42629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42630       };
42631     } catch (std::exception& e) {
42632       {
42633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42634       };
42635     } catch (Dali::DaliException e) {
42636       {
42637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42638       };
42639     } catch (...) {
42640       {
42641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42642       };
42643     }
42644   }
42645
42646 }
42647
42648
42649 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
42650   int jresult ;
42651   int result;
42652
42653   result = (int)Dali::Path::Property::POINTS;
42654   jresult = (int)result;
42655   return jresult;
42656 }
42657
42658
42659 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
42660   int jresult ;
42661   int result;
42662
42663   result = (int)Dali::Path::Property::CONTROL_POINTS;
42664   jresult = (int)result;
42665   return jresult;
42666 }
42667
42668
42669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
42670   void * jresult ;
42671   Dali::Path::Property *result = 0 ;
42672
42673   {
42674     try {
42675       result = (Dali::Path::Property *)new Dali::Path::Property();
42676     } catch (std::out_of_range& e) {
42677       {
42678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42679       };
42680     } catch (std::exception& e) {
42681       {
42682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42683       };
42684     } catch (Dali::DaliException e) {
42685       {
42686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42687       };
42688     } catch (...) {
42689       {
42690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42691       };
42692     }
42693   }
42694
42695   jresult = (void *)result;
42696   return jresult;
42697 }
42698
42699
42700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
42701   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
42702
42703   arg1 = (Dali::Path::Property *)jarg1;
42704   {
42705     try {
42706       delete arg1;
42707     } catch (std::out_of_range& e) {
42708       {
42709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42710       };
42711     } catch (std::exception& e) {
42712       {
42713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42714       };
42715     } catch (Dali::DaliException e) {
42716       {
42717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42718       };
42719     } catch (...) {
42720       {
42721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42722       };
42723     }
42724   }
42725
42726 }
42727
42728
42729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
42730   void * jresult ;
42731   Dali::Path result;
42732
42733   {
42734     try {
42735       result = Dali::Path::New();
42736     } catch (std::out_of_range& e) {
42737       {
42738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42739       };
42740     } catch (std::exception& e) {
42741       {
42742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42743       };
42744     } catch (Dali::DaliException e) {
42745       {
42746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42747       };
42748     } catch (...) {
42749       {
42750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42751       };
42752     }
42753   }
42754
42755   jresult = new Dali::Path((const Dali::Path &)result);
42756   return jresult;
42757 }
42758
42759
42760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
42761   void * jresult ;
42762   Dali::BaseHandle arg1 ;
42763   Dali::BaseHandle *argp1 ;
42764   Dali::Path result;
42765
42766   argp1 = (Dali::BaseHandle *)jarg1;
42767   if (!argp1) {
42768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42769     return 0;
42770   }
42771   arg1 = *argp1;
42772   {
42773     try {
42774       result = Dali::Path::DownCast(arg1);
42775     } catch (std::out_of_range& e) {
42776       {
42777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42778       };
42779     } catch (std::exception& e) {
42780       {
42781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42782       };
42783     } catch (Dali::DaliException e) {
42784       {
42785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42786       };
42787     } catch (...) {
42788       {
42789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42790       };
42791     }
42792   }
42793
42794   jresult = new Dali::Path((const Dali::Path &)result);
42795   return jresult;
42796 }
42797
42798
42799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
42800   void * jresult ;
42801   Dali::Path *result = 0 ;
42802
42803   {
42804     try {
42805       result = (Dali::Path *)new Dali::Path();
42806     } catch (std::out_of_range& e) {
42807       {
42808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42809       };
42810     } catch (std::exception& e) {
42811       {
42812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42813       };
42814     } catch (Dali::DaliException e) {
42815       {
42816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42817       };
42818     } catch (...) {
42819       {
42820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42821       };
42822     }
42823   }
42824
42825   jresult = (void *)result;
42826   return jresult;
42827 }
42828
42829
42830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
42831   Dali::Path *arg1 = (Dali::Path *) 0 ;
42832
42833   arg1 = (Dali::Path *)jarg1;
42834   {
42835     try {
42836       delete arg1;
42837     } catch (std::out_of_range& e) {
42838       {
42839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42840       };
42841     } catch (std::exception& e) {
42842       {
42843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42844       };
42845     } catch (Dali::DaliException e) {
42846       {
42847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42848       };
42849     } catch (...) {
42850       {
42851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42852       };
42853     }
42854   }
42855
42856 }
42857
42858
42859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
42860   void * jresult ;
42861   Dali::Path *arg1 = 0 ;
42862   Dali::Path *result = 0 ;
42863
42864   arg1 = (Dali::Path *)jarg1;
42865   if (!arg1) {
42866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
42867     return 0;
42868   }
42869   {
42870     try {
42871       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
42872     } catch (std::out_of_range& e) {
42873       {
42874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42875       };
42876     } catch (std::exception& e) {
42877       {
42878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42879       };
42880     } catch (Dali::DaliException e) {
42881       {
42882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42883       };
42884     } catch (...) {
42885       {
42886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42887       };
42888     }
42889   }
42890
42891   jresult = (void *)result;
42892   return jresult;
42893 }
42894
42895
42896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
42897   void * jresult ;
42898   Dali::Path *arg1 = (Dali::Path *) 0 ;
42899   Dali::Path *arg2 = 0 ;
42900   Dali::Path *result = 0 ;
42901
42902   arg1 = (Dali::Path *)jarg1;
42903   arg2 = (Dali::Path *)jarg2;
42904   if (!arg2) {
42905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
42906     return 0;
42907   }
42908   {
42909     try {
42910       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
42911     } catch (std::out_of_range& e) {
42912       {
42913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42914       };
42915     } catch (std::exception& e) {
42916       {
42917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42918       };
42919     } catch (Dali::DaliException e) {
42920       {
42921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42922       };
42923     } catch (...) {
42924       {
42925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42926       };
42927     }
42928   }
42929
42930   jresult = (void *)result;
42931   return jresult;
42932 }
42933
42934
42935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
42936   Dali::Path *arg1 = (Dali::Path *) 0 ;
42937   Dali::Vector3 *arg2 = 0 ;
42938
42939   arg1 = (Dali::Path *)jarg1;
42940   arg2 = (Dali::Vector3 *)jarg2;
42941   if (!arg2) {
42942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42943     return ;
42944   }
42945   {
42946     try {
42947       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
42948     } catch (std::out_of_range& e) {
42949       {
42950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42951       };
42952     } catch (std::exception& e) {
42953       {
42954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42955       };
42956     } catch (Dali::DaliException e) {
42957       {
42958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42959       };
42960     } catch (...) {
42961       {
42962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42963       };
42964     }
42965   }
42966
42967 }
42968
42969
42970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
42971   Dali::Path *arg1 = (Dali::Path *) 0 ;
42972   Dali::Vector3 *arg2 = 0 ;
42973
42974   arg1 = (Dali::Path *)jarg1;
42975   arg2 = (Dali::Vector3 *)jarg2;
42976   if (!arg2) {
42977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42978     return ;
42979   }
42980   {
42981     try {
42982       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
42983     } catch (std::out_of_range& e) {
42984       {
42985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42986       };
42987     } catch (std::exception& e) {
42988       {
42989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42990       };
42991     } catch (Dali::DaliException e) {
42992       {
42993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42994       };
42995     } catch (...) {
42996       {
42997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42998       };
42999     }
43000   }
43001
43002 }
43003
43004
43005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43006   Dali::Path *arg1 = (Dali::Path *) 0 ;
43007   float arg2 ;
43008
43009   arg1 = (Dali::Path *)jarg1;
43010   arg2 = (float)jarg2;
43011   {
43012     try {
43013       (arg1)->GenerateControlPoints(arg2);
43014     } catch (std::out_of_range& e) {
43015       {
43016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43017       };
43018     } catch (std::exception& e) {
43019       {
43020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43021       };
43022     } catch (Dali::DaliException e) {
43023       {
43024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43025       };
43026     } catch (...) {
43027       {
43028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43029       };
43030     }
43031   }
43032
43033 }
43034
43035
43036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43037   Dali::Path *arg1 = (Dali::Path *) 0 ;
43038   float arg2 ;
43039   Dali::Vector3 *arg3 = 0 ;
43040   Dali::Vector3 *arg4 = 0 ;
43041
43042   arg1 = (Dali::Path *)jarg1;
43043   arg2 = (float)jarg2;
43044   arg3 = (Dali::Vector3 *)jarg3;
43045   if (!arg3) {
43046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43047     return ;
43048   }
43049   arg4 = (Dali::Vector3 *)jarg4;
43050   if (!arg4) {
43051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43052     return ;
43053   }
43054   {
43055     try {
43056       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43057     } catch (std::out_of_range& e) {
43058       {
43059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43060       };
43061     } catch (std::exception& e) {
43062       {
43063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43064       };
43065     } catch (Dali::DaliException e) {
43066       {
43067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43068       };
43069     } catch (...) {
43070       {
43071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43072       };
43073     }
43074   }
43075
43076 }
43077
43078
43079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43080   void * jresult ;
43081   Dali::Path *arg1 = (Dali::Path *) 0 ;
43082   size_t arg2 ;
43083   Dali::Vector3 *result = 0 ;
43084
43085   arg1 = (Dali::Path *)jarg1;
43086   arg2 = (size_t)jarg2;
43087   {
43088     try {
43089       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43090     } catch (std::out_of_range& e) {
43091       {
43092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43093       };
43094     } catch (std::exception& e) {
43095       {
43096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43097       };
43098     } catch (Dali::DaliException e) {
43099       {
43100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43101       };
43102     } catch (...) {
43103       {
43104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43105       };
43106     }
43107   }
43108
43109   jresult = (void *)result;
43110   return jresult;
43111 }
43112
43113
43114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43115   void * jresult ;
43116   Dali::Path *arg1 = (Dali::Path *) 0 ;
43117   size_t arg2 ;
43118   Dali::Vector3 *result = 0 ;
43119
43120   arg1 = (Dali::Path *)jarg1;
43121   arg2 = (size_t)jarg2;
43122   {
43123     try {
43124       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43125     } catch (std::out_of_range& e) {
43126       {
43127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43128       };
43129     } catch (std::exception& e) {
43130       {
43131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43132       };
43133     } catch (Dali::DaliException e) {
43134       {
43135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43136       };
43137     } catch (...) {
43138       {
43139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43140       };
43141     }
43142   }
43143
43144   jresult = (void *)result;
43145   return jresult;
43146 }
43147
43148
43149 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43150   unsigned long jresult ;
43151   Dali::Path *arg1 = (Dali::Path *) 0 ;
43152   size_t result;
43153
43154   arg1 = (Dali::Path *)jarg1;
43155   {
43156     try {
43157       result = ((Dali::Path const *)arg1)->GetPointCount();
43158     } catch (std::out_of_range& e) {
43159       {
43160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43161       };
43162     } catch (std::exception& e) {
43163       {
43164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43165       };
43166     } catch (Dali::DaliException e) {
43167       {
43168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43169       };
43170     } catch (...) {
43171       {
43172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43173       };
43174     }
43175   }
43176
43177   jresult = (unsigned long)result;
43178   return jresult;
43179 }
43180
43181
43182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43183   void * jresult ;
43184   float arg1 ;
43185   Dali::TimePeriod *result = 0 ;
43186
43187   arg1 = (float)jarg1;
43188   {
43189     try {
43190       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43191     } catch (std::out_of_range& e) {
43192       {
43193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43194       };
43195     } catch (std::exception& e) {
43196       {
43197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43198       };
43199     } catch (Dali::DaliException e) {
43200       {
43201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43202       };
43203     } catch (...) {
43204       {
43205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43206       };
43207     }
43208   }
43209
43210   jresult = (void *)result;
43211   return jresult;
43212 }
43213
43214
43215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43216   void * jresult ;
43217   float arg1 ;
43218   float arg2 ;
43219   Dali::TimePeriod *result = 0 ;
43220
43221   arg1 = (float)jarg1;
43222   arg2 = (float)jarg2;
43223   {
43224     try {
43225       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43226     } catch (std::out_of_range& e) {
43227       {
43228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43229       };
43230     } catch (std::exception& e) {
43231       {
43232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43233       };
43234     } catch (Dali::DaliException e) {
43235       {
43236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43237       };
43238     } catch (...) {
43239       {
43240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43241       };
43242     }
43243   }
43244
43245   jresult = (void *)result;
43246   return jresult;
43247 }
43248
43249
43250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
43251   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43252
43253   arg1 = (Dali::TimePeriod *)jarg1;
43254   {
43255     try {
43256       delete arg1;
43257     } catch (std::out_of_range& e) {
43258       {
43259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43260       };
43261     } catch (std::exception& e) {
43262       {
43263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43264       };
43265     } catch (Dali::DaliException e) {
43266       {
43267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43268       };
43269     } catch (...) {
43270       {
43271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43272       };
43273     }
43274   }
43275
43276 }
43277
43278
43279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
43280   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43281   float arg2 ;
43282
43283   arg1 = (Dali::TimePeriod *)jarg1;
43284   arg2 = (float)jarg2;
43285   if (arg1) (arg1)->delaySeconds = arg2;
43286 }
43287
43288
43289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
43290   float jresult ;
43291   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43292   float result;
43293
43294   arg1 = (Dali::TimePeriod *)jarg1;
43295   result = (float) ((arg1)->delaySeconds);
43296   jresult = result;
43297   return jresult;
43298 }
43299
43300
43301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
43302   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43303   float arg2 ;
43304
43305   arg1 = (Dali::TimePeriod *)jarg1;
43306   arg2 = (float)jarg2;
43307   if (arg1) (arg1)->durationSeconds = arg2;
43308 }
43309
43310
43311 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
43312   float jresult ;
43313   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43314   float result;
43315
43316   arg1 = (Dali::TimePeriod *)jarg1;
43317   result = (float) ((arg1)->durationSeconds);
43318   jresult = result;
43319   return jresult;
43320 }
43321
43322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
43323   int jresult ;
43324   int result;
43325
43326   result = (int)Dali::LinearConstrainer::Property::VALUE;
43327   jresult = (int)result;
43328   return jresult;
43329 }
43330
43331
43332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
43333   int jresult ;
43334   int result;
43335
43336   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
43337   jresult = (int)result;
43338   return jresult;
43339 }
43340
43341
43342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
43343   void * jresult ;
43344   Dali::LinearConstrainer::Property *result = 0 ;
43345
43346   {
43347     try {
43348       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
43349     } catch (std::out_of_range& e) {
43350       {
43351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43352       };
43353     } catch (std::exception& e) {
43354       {
43355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43356       };
43357     } catch (Dali::DaliException e) {
43358       {
43359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43360       };
43361     } catch (...) {
43362       {
43363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43364       };
43365     }
43366   }
43367
43368   jresult = (void *)result;
43369   return jresult;
43370 }
43371
43372
43373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
43374   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
43375
43376   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
43377   {
43378     try {
43379       delete arg1;
43380     } catch (std::out_of_range& e) {
43381       {
43382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43383       };
43384     } catch (std::exception& e) {
43385       {
43386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43387       };
43388     } catch (Dali::DaliException e) {
43389       {
43390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43391       };
43392     } catch (...) {
43393       {
43394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43395       };
43396     }
43397   }
43398
43399 }
43400
43401
43402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
43403   void * jresult ;
43404   Dali::LinearConstrainer result;
43405
43406   {
43407     try {
43408       result = Dali::LinearConstrainer::New();
43409     } catch (std::out_of_range& e) {
43410       {
43411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43412       };
43413     } catch (std::exception& e) {
43414       {
43415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43416       };
43417     } catch (Dali::DaliException e) {
43418       {
43419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43420       };
43421     } catch (...) {
43422       {
43423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43424       };
43425     }
43426   }
43427
43428   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43429   return jresult;
43430 }
43431
43432
43433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
43434   void * jresult ;
43435   Dali::BaseHandle arg1 ;
43436   Dali::BaseHandle *argp1 ;
43437   Dali::LinearConstrainer result;
43438
43439   argp1 = (Dali::BaseHandle *)jarg1;
43440   if (!argp1) {
43441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43442     return 0;
43443   }
43444   arg1 = *argp1;
43445   {
43446     try {
43447       result = Dali::LinearConstrainer::DownCast(arg1);
43448     } catch (std::out_of_range& e) {
43449       {
43450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43451       };
43452     } catch (std::exception& e) {
43453       {
43454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43455       };
43456     } catch (Dali::DaliException e) {
43457       {
43458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43459       };
43460     } catch (...) {
43461       {
43462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43463       };
43464     }
43465   }
43466
43467   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43468   return jresult;
43469 }
43470
43471
43472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
43473   void * jresult ;
43474   Dali::LinearConstrainer *result = 0 ;
43475
43476   {
43477     try {
43478       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
43479     } catch (std::out_of_range& e) {
43480       {
43481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43482       };
43483     } catch (std::exception& e) {
43484       {
43485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43486       };
43487     } catch (Dali::DaliException e) {
43488       {
43489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43490       };
43491     } catch (...) {
43492       {
43493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43494       };
43495     }
43496   }
43497
43498   jresult = (void *)result;
43499   return jresult;
43500 }
43501
43502
43503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
43504   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43505
43506   arg1 = (Dali::LinearConstrainer *)jarg1;
43507   {
43508     try {
43509       delete arg1;
43510     } catch (std::out_of_range& e) {
43511       {
43512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43513       };
43514     } catch (std::exception& e) {
43515       {
43516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43517       };
43518     } catch (Dali::DaliException e) {
43519       {
43520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43521       };
43522     } catch (...) {
43523       {
43524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43525       };
43526     }
43527   }
43528
43529 }
43530
43531
43532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
43533   void * jresult ;
43534   Dali::LinearConstrainer *arg1 = 0 ;
43535   Dali::LinearConstrainer *result = 0 ;
43536
43537   arg1 = (Dali::LinearConstrainer *)jarg1;
43538   if (!arg1) {
43539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43540     return 0;
43541   }
43542   {
43543     try {
43544       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
43545     } catch (std::out_of_range& e) {
43546       {
43547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43548       };
43549     } catch (std::exception& e) {
43550       {
43551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43552       };
43553     } catch (Dali::DaliException e) {
43554       {
43555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43556       };
43557     } catch (...) {
43558       {
43559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43560       };
43561     }
43562   }
43563
43564   jresult = (void *)result;
43565   return jresult;
43566 }
43567
43568
43569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
43570   void * jresult ;
43571   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43572   Dali::LinearConstrainer *arg2 = 0 ;
43573   Dali::LinearConstrainer *result = 0 ;
43574
43575   arg1 = (Dali::LinearConstrainer *)jarg1;
43576   arg2 = (Dali::LinearConstrainer *)jarg2;
43577   if (!arg2) {
43578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43579     return 0;
43580   }
43581   {
43582     try {
43583       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
43584     } catch (std::out_of_range& e) {
43585       {
43586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43587       };
43588     } catch (std::exception& e) {
43589       {
43590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43591       };
43592     } catch (Dali::DaliException e) {
43593       {
43594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43595       };
43596     } catch (...) {
43597       {
43598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43599       };
43600     }
43601   }
43602
43603   jresult = (void *)result;
43604   return jresult;
43605 }
43606
43607
43608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
43609   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43610   SwigValueWrapper< Dali::Property > arg2 ;
43611   SwigValueWrapper< Dali::Property > arg3 ;
43612   Dali::Vector2 *arg4 = 0 ;
43613   Dali::Vector2 *arg5 = 0 ;
43614   Dali::Property *argp2 ;
43615   Dali::Property *argp3 ;
43616
43617   arg1 = (Dali::LinearConstrainer *)jarg1;
43618   argp2 = (Dali::Property *)jarg2;
43619   if (!argp2) {
43620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43621     return ;
43622   }
43623   arg2 = *argp2;
43624   argp3 = (Dali::Property *)jarg3;
43625   if (!argp3) {
43626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43627     return ;
43628   }
43629   arg3 = *argp3;
43630   arg4 = (Dali::Vector2 *)jarg4;
43631   if (!arg4) {
43632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43633     return ;
43634   }
43635   arg5 = (Dali::Vector2 *)jarg5;
43636   if (!arg5) {
43637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43638     return ;
43639   }
43640   {
43641     try {
43642       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
43643     } catch (std::out_of_range& e) {
43644       {
43645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43646       };
43647     } catch (std::exception& e) {
43648       {
43649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43650       };
43651     } catch (Dali::DaliException e) {
43652       {
43653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43654       };
43655     } catch (...) {
43656       {
43657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43658       };
43659     }
43660   }
43661
43662 }
43663
43664
43665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
43666   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43667   SwigValueWrapper< Dali::Property > arg2 ;
43668   SwigValueWrapper< Dali::Property > arg3 ;
43669   Dali::Vector2 *arg4 = 0 ;
43670   Dali::Property *argp2 ;
43671   Dali::Property *argp3 ;
43672
43673   arg1 = (Dali::LinearConstrainer *)jarg1;
43674   argp2 = (Dali::Property *)jarg2;
43675   if (!argp2) {
43676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43677     return ;
43678   }
43679   arg2 = *argp2;
43680   argp3 = (Dali::Property *)jarg3;
43681   if (!argp3) {
43682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43683     return ;
43684   }
43685   arg3 = *argp3;
43686   arg4 = (Dali::Vector2 *)jarg4;
43687   if (!arg4) {
43688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43689     return ;
43690   }
43691   {
43692     try {
43693       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
43694     } catch (std::out_of_range& e) {
43695       {
43696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43697       };
43698     } catch (std::exception& e) {
43699       {
43700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43701       };
43702     } catch (Dali::DaliException e) {
43703       {
43704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43705       };
43706     } catch (...) {
43707       {
43708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43709       };
43710     }
43711   }
43712
43713 }
43714
43715
43716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
43717   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43718   Dali::Handle *arg2 = 0 ;
43719
43720   arg1 = (Dali::LinearConstrainer *)jarg1;
43721   arg2 = (Dali::Handle *)jarg2;
43722   if (!arg2) {
43723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
43724     return ;
43725   }
43726   {
43727     try {
43728       (arg1)->Remove(*arg2);
43729     } catch (std::out_of_range& e) {
43730       {
43731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43732       };
43733     } catch (std::exception& e) {
43734       {
43735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43736       };
43737     } catch (Dali::DaliException e) {
43738       {
43739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43740       };
43741     } catch (...) {
43742       {
43743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43744       };
43745     }
43746   }
43747
43748 }
43749
43750
43751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
43752   int jresult ;
43753   int result;
43754
43755   result = (int)Dali::PathConstrainer::Property::FORWARD;
43756   jresult = (int)result;
43757   return jresult;
43758 }
43759
43760
43761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
43762   int jresult ;
43763   int result;
43764
43765   result = (int)Dali::PathConstrainer::Property::POINTS;
43766   jresult = (int)result;
43767   return jresult;
43768 }
43769
43770
43771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
43772   int jresult ;
43773   int result;
43774
43775   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
43776   jresult = (int)result;
43777   return jresult;
43778 }
43779
43780
43781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
43782   void * jresult ;
43783   Dali::PathConstrainer::Property *result = 0 ;
43784
43785   {
43786     try {
43787       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
43788     } catch (std::out_of_range& e) {
43789       {
43790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43791       };
43792     } catch (std::exception& e) {
43793       {
43794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43795       };
43796     } catch (Dali::DaliException e) {
43797       {
43798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43799       };
43800     } catch (...) {
43801       {
43802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43803       };
43804     }
43805   }
43806
43807   jresult = (void *)result;
43808   return jresult;
43809 }
43810
43811
43812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
43813   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
43814
43815   arg1 = (Dali::PathConstrainer::Property *)jarg1;
43816   {
43817     try {
43818       delete arg1;
43819     } catch (std::out_of_range& e) {
43820       {
43821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43822       };
43823     } catch (std::exception& e) {
43824       {
43825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43826       };
43827     } catch (Dali::DaliException e) {
43828       {
43829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43830       };
43831     } catch (...) {
43832       {
43833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43834       };
43835     }
43836   }
43837
43838 }
43839
43840
43841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
43842   void * jresult ;
43843   Dali::PathConstrainer result;
43844
43845   {
43846     try {
43847       result = Dali::PathConstrainer::New();
43848     } catch (std::out_of_range& e) {
43849       {
43850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43851       };
43852     } catch (std::exception& e) {
43853       {
43854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43855       };
43856     } catch (Dali::DaliException e) {
43857       {
43858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43859       };
43860     } catch (...) {
43861       {
43862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43863       };
43864     }
43865   }
43866
43867   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
43868   return jresult;
43869 }
43870
43871
43872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
43873   void * jresult ;
43874   Dali::BaseHandle arg1 ;
43875   Dali::BaseHandle *argp1 ;
43876   Dali::PathConstrainer result;
43877
43878   argp1 = (Dali::BaseHandle *)jarg1;
43879   if (!argp1) {
43880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43881     return 0;
43882   }
43883   arg1 = *argp1;
43884   {
43885     try {
43886       result = Dali::PathConstrainer::DownCast(arg1);
43887     } catch (std::out_of_range& e) {
43888       {
43889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43890       };
43891     } catch (std::exception& e) {
43892       {
43893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43894       };
43895     } catch (Dali::DaliException e) {
43896       {
43897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43898       };
43899     } catch (...) {
43900       {
43901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43902       };
43903     }
43904   }
43905
43906   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
43907   return jresult;
43908 }
43909
43910
43911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
43912   void * jresult ;
43913   Dali::PathConstrainer *result = 0 ;
43914
43915   {
43916     try {
43917       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
43918     } catch (std::out_of_range& e) {
43919       {
43920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43921       };
43922     } catch (std::exception& e) {
43923       {
43924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43925       };
43926     } catch (Dali::DaliException e) {
43927       {
43928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43929       };
43930     } catch (...) {
43931       {
43932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43933       };
43934     }
43935   }
43936
43937   jresult = (void *)result;
43938   return jresult;
43939 }
43940
43941
43942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
43943   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
43944
43945   arg1 = (Dali::PathConstrainer *)jarg1;
43946   {
43947     try {
43948       delete arg1;
43949     } catch (std::out_of_range& e) {
43950       {
43951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43952       };
43953     } catch (std::exception& e) {
43954       {
43955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43956       };
43957     } catch (Dali::DaliException e) {
43958       {
43959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43960       };
43961     } catch (...) {
43962       {
43963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43964       };
43965     }
43966   }
43967
43968 }
43969
43970
43971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
43972   void * jresult ;
43973   Dali::PathConstrainer *arg1 = 0 ;
43974   Dali::PathConstrainer *result = 0 ;
43975
43976   arg1 = (Dali::PathConstrainer *)jarg1;
43977   if (!arg1) {
43978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
43979     return 0;
43980   }
43981   {
43982     try {
43983       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
43984     } catch (std::out_of_range& e) {
43985       {
43986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43987       };
43988     } catch (std::exception& e) {
43989       {
43990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43991       };
43992     } catch (Dali::DaliException e) {
43993       {
43994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43995       };
43996     } catch (...) {
43997       {
43998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43999       };
44000     }
44001   }
44002
44003   jresult = (void *)result;
44004   return jresult;
44005 }
44006
44007
44008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44009   void * jresult ;
44010   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44011   Dali::PathConstrainer *arg2 = 0 ;
44012   Dali::PathConstrainer *result = 0 ;
44013
44014   arg1 = (Dali::PathConstrainer *)jarg1;
44015   arg2 = (Dali::PathConstrainer *)jarg2;
44016   if (!arg2) {
44017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44018     return 0;
44019   }
44020   {
44021     try {
44022       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44023     } catch (std::out_of_range& e) {
44024       {
44025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44026       };
44027     } catch (std::exception& e) {
44028       {
44029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44030       };
44031     } catch (Dali::DaliException e) {
44032       {
44033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44034       };
44035     } catch (...) {
44036       {
44037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44038       };
44039     }
44040   }
44041
44042   jresult = (void *)result;
44043   return jresult;
44044 }
44045
44046
44047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44048   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44049   SwigValueWrapper< Dali::Property > arg2 ;
44050   SwigValueWrapper< Dali::Property > arg3 ;
44051   Dali::Vector2 *arg4 = 0 ;
44052   Dali::Vector2 *arg5 = 0 ;
44053   Dali::Property *argp2 ;
44054   Dali::Property *argp3 ;
44055
44056   arg1 = (Dali::PathConstrainer *)jarg1;
44057   argp2 = (Dali::Property *)jarg2;
44058   if (!argp2) {
44059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44060     return ;
44061   }
44062   arg2 = *argp2;
44063   argp3 = (Dali::Property *)jarg3;
44064   if (!argp3) {
44065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44066     return ;
44067   }
44068   arg3 = *argp3;
44069   arg4 = (Dali::Vector2 *)jarg4;
44070   if (!arg4) {
44071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44072     return ;
44073   }
44074   arg5 = (Dali::Vector2 *)jarg5;
44075   if (!arg5) {
44076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44077     return ;
44078   }
44079   {
44080     try {
44081       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44082     } catch (std::out_of_range& e) {
44083       {
44084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44085       };
44086     } catch (std::exception& e) {
44087       {
44088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44089       };
44090     } catch (Dali::DaliException e) {
44091       {
44092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44093       };
44094     } catch (...) {
44095       {
44096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44097       };
44098     }
44099   }
44100
44101 }
44102
44103
44104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44105   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44106   SwigValueWrapper< Dali::Property > arg2 ;
44107   SwigValueWrapper< Dali::Property > arg3 ;
44108   Dali::Vector2 *arg4 = 0 ;
44109   Dali::Property *argp2 ;
44110   Dali::Property *argp3 ;
44111
44112   arg1 = (Dali::PathConstrainer *)jarg1;
44113   argp2 = (Dali::Property *)jarg2;
44114   if (!argp2) {
44115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44116     return ;
44117   }
44118   arg2 = *argp2;
44119   argp3 = (Dali::Property *)jarg3;
44120   if (!argp3) {
44121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44122     return ;
44123   }
44124   arg3 = *argp3;
44125   arg4 = (Dali::Vector2 *)jarg4;
44126   if (!arg4) {
44127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44128     return ;
44129   }
44130   {
44131     try {
44132       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44133     } catch (std::out_of_range& e) {
44134       {
44135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44136       };
44137     } catch (std::exception& e) {
44138       {
44139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44140       };
44141     } catch (Dali::DaliException e) {
44142       {
44143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44144       };
44145     } catch (...) {
44146       {
44147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44148       };
44149     }
44150   }
44151
44152 }
44153
44154
44155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44156   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44157   Dali::Handle *arg2 = 0 ;
44158
44159   arg1 = (Dali::PathConstrainer *)jarg1;
44160   arg2 = (Dali::Handle *)jarg2;
44161   if (!arg2) {
44162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44163     return ;
44164   }
44165   {
44166     try {
44167       (arg1)->Remove(*arg2);
44168     } catch (std::out_of_range& e) {
44169       {
44170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44171       };
44172     } catch (std::exception& e) {
44173       {
44174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44175       };
44176     } catch (Dali::DaliException e) {
44177       {
44178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44179       };
44180     } catch (...) {
44181       {
44182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44183       };
44184     }
44185   }
44186
44187 }
44188
44189
44190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44191   int jresult ;
44192   Dali::FittingMode::Type result;
44193
44194   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44195   jresult = (int)result;
44196   return jresult;
44197 }
44198
44199
44200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44201   int jresult ;
44202   Dali::SamplingMode::Type result;
44203
44204   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44205   jresult = (int)result;
44206   return jresult;
44207 }
44208
44209
44210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
44211   unsigned int jresult ;
44212   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44213   bool result;
44214
44215   arg1 = (Dali::NativeImageInterface *)jarg1;
44216   {
44217     try {
44218       result = (bool)(arg1)->CreateResource();
44219     } catch (std::out_of_range& e) {
44220       {
44221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44222       };
44223     } catch (std::exception& e) {
44224       {
44225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44226       };
44227     } catch (Dali::DaliException e) {
44228       {
44229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44230       };
44231     } catch (...) {
44232       {
44233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44234       };
44235     }
44236   }
44237
44238   jresult = result;
44239   return jresult;
44240 }
44241
44242
44243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
44244   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44245
44246   arg1 = (Dali::NativeImageInterface *)jarg1;
44247   {
44248     try {
44249       (arg1)->DestroyResource();
44250     } catch (std::out_of_range& e) {
44251       {
44252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44253       };
44254     } catch (std::exception& e) {
44255       {
44256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44257       };
44258     } catch (Dali::DaliException e) {
44259       {
44260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44261       };
44262     } catch (...) {
44263       {
44264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44265       };
44266     }
44267   }
44268
44269 }
44270
44271
44272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
44273   unsigned int jresult ;
44274   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44275   unsigned int result;
44276
44277   arg1 = (Dali::NativeImageInterface *)jarg1;
44278   {
44279     try {
44280       result = (unsigned int)(arg1)->TargetTexture();
44281     } catch (std::out_of_range& e) {
44282       {
44283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44284       };
44285     } catch (std::exception& e) {
44286       {
44287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44288       };
44289     } catch (Dali::DaliException e) {
44290       {
44291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44292       };
44293     } catch (...) {
44294       {
44295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44296       };
44297     }
44298   }
44299
44300   jresult = result;
44301   return jresult;
44302 }
44303
44304
44305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
44306   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44307
44308   arg1 = (Dali::NativeImageInterface *)jarg1;
44309   {
44310     try {
44311       (arg1)->PrepareTexture();
44312     } catch (std::out_of_range& e) {
44313       {
44314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44315       };
44316     } catch (std::exception& e) {
44317       {
44318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44319       };
44320     } catch (Dali::DaliException e) {
44321       {
44322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44323       };
44324     } catch (...) {
44325       {
44326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44327       };
44328     }
44329   }
44330
44331 }
44332
44333
44334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
44335   unsigned int jresult ;
44336   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44337   unsigned int result;
44338
44339   arg1 = (Dali::NativeImageInterface *)jarg1;
44340   {
44341     try {
44342       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
44343     } catch (std::out_of_range& e) {
44344       {
44345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44346       };
44347     } catch (std::exception& e) {
44348       {
44349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44350       };
44351     } catch (Dali::DaliException e) {
44352       {
44353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44354       };
44355     } catch (...) {
44356       {
44357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44358       };
44359     }
44360   }
44361
44362   jresult = result;
44363   return jresult;
44364 }
44365
44366
44367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
44368   unsigned int jresult ;
44369   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44370   unsigned int result;
44371
44372   arg1 = (Dali::NativeImageInterface *)jarg1;
44373   {
44374     try {
44375       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
44376     } catch (std::out_of_range& e) {
44377       {
44378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44379       };
44380     } catch (std::exception& e) {
44381       {
44382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44383       };
44384     } catch (Dali::DaliException e) {
44385       {
44386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44387       };
44388     } catch (...) {
44389       {
44390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44391       };
44392     }
44393   }
44394
44395   jresult = result;
44396   return jresult;
44397 }
44398
44399
44400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
44401   unsigned int jresult ;
44402   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44403   bool result;
44404
44405   arg1 = (Dali::NativeImageInterface *)jarg1;
44406   {
44407     try {
44408       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
44409     } catch (std::out_of_range& e) {
44410       {
44411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44412       };
44413     } catch (std::exception& e) {
44414       {
44415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44416       };
44417     } catch (Dali::DaliException e) {
44418       {
44419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44420       };
44421     } catch (...) {
44422       {
44423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44424       };
44425     }
44426   }
44427
44428   jresult = result;
44429   return jresult;
44430 }
44431
44432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
44433   int jresult ;
44434   int result;
44435
44436   result = (int)Dali::CameraActor::Property::TYPE;
44437   jresult = (int)result;
44438   return jresult;
44439 }
44440
44441
44442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
44443   int jresult ;
44444   int result;
44445
44446   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
44447   jresult = (int)result;
44448   return jresult;
44449 }
44450
44451
44452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
44453   int jresult ;
44454   int result;
44455
44456   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
44457   jresult = (int)result;
44458   return jresult;
44459 }
44460
44461
44462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
44463   int jresult ;
44464   int result;
44465
44466   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
44467   jresult = (int)result;
44468   return jresult;
44469 }
44470
44471
44472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
44473   int jresult ;
44474   int result;
44475
44476   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
44477   jresult = (int)result;
44478   return jresult;
44479 }
44480
44481
44482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
44483   int jresult ;
44484   int result;
44485
44486   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
44487   jresult = (int)result;
44488   return jresult;
44489 }
44490
44491
44492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
44493   int jresult ;
44494   int result;
44495
44496   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
44497   jresult = (int)result;
44498   return jresult;
44499 }
44500
44501
44502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
44503   int jresult ;
44504   int result;
44505
44506   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
44507   jresult = (int)result;
44508   return jresult;
44509 }
44510
44511
44512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
44513   int jresult ;
44514   int result;
44515
44516   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
44517   jresult = (int)result;
44518   return jresult;
44519 }
44520
44521
44522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
44523   int jresult ;
44524   int result;
44525
44526   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
44527   jresult = (int)result;
44528   return jresult;
44529 }
44530
44531
44532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
44533   int jresult ;
44534   int result;
44535
44536   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
44537   jresult = (int)result;
44538   return jresult;
44539 }
44540
44541
44542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
44543   int jresult ;
44544   int result;
44545
44546   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
44547   jresult = (int)result;
44548   return jresult;
44549 }
44550
44551
44552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
44553   int jresult ;
44554   int result;
44555
44556   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
44557   jresult = (int)result;
44558   return jresult;
44559 }
44560
44561
44562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
44563   int jresult ;
44564   int result;
44565
44566   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
44567   jresult = (int)result;
44568   return jresult;
44569 }
44570
44571
44572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
44573   void * jresult ;
44574   Dali::CameraActor::Property *result = 0 ;
44575
44576   {
44577     try {
44578       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
44579     } catch (std::out_of_range& e) {
44580       {
44581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44582       };
44583     } catch (std::exception& e) {
44584       {
44585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44586       };
44587     } catch (Dali::DaliException e) {
44588       {
44589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44590       };
44591     } catch (...) {
44592       {
44593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44594       };
44595     }
44596   }
44597
44598   jresult = (void *)result;
44599   return jresult;
44600 }
44601
44602
44603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
44604   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
44605
44606   arg1 = (Dali::CameraActor::Property *)jarg1;
44607   {
44608     try {
44609       delete arg1;
44610     } catch (std::out_of_range& e) {
44611       {
44612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44613       };
44614     } catch (std::exception& e) {
44615       {
44616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44617       };
44618     } catch (Dali::DaliException e) {
44619       {
44620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44621       };
44622     } catch (...) {
44623       {
44624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44625       };
44626     }
44627   }
44628
44629 }
44630
44631
44632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
44633   void * jresult ;
44634   Dali::CameraActor *result = 0 ;
44635
44636   {
44637     try {
44638       result = (Dali::CameraActor *)new Dali::CameraActor();
44639     } catch (std::out_of_range& e) {
44640       {
44641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44642       };
44643     } catch (std::exception& e) {
44644       {
44645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44646       };
44647     } catch (Dali::DaliException e) {
44648       {
44649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44650       };
44651     } catch (...) {
44652       {
44653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44654       };
44655     }
44656   }
44657
44658   jresult = (void *)result;
44659   return jresult;
44660 }
44661
44662
44663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
44664   void * jresult ;
44665   Dali::CameraActor result;
44666
44667   {
44668     try {
44669       result = Dali::CameraActor::New();
44670     } catch (std::out_of_range& e) {
44671       {
44672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44673       };
44674     } catch (std::exception& e) {
44675       {
44676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44677       };
44678     } catch (Dali::DaliException e) {
44679       {
44680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44681       };
44682     } catch (...) {
44683       {
44684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44685       };
44686     }
44687   }
44688
44689   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44690   return jresult;
44691 }
44692
44693
44694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
44695   void * jresult ;
44696   Dali::Size *arg1 = 0 ;
44697   Dali::CameraActor result;
44698
44699   arg1 = (Dali::Size *)jarg1;
44700   if (!arg1) {
44701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44702     return 0;
44703   }
44704   {
44705     try {
44706       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
44707     } catch (std::out_of_range& e) {
44708       {
44709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44710       };
44711     } catch (std::exception& e) {
44712       {
44713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44714       };
44715     } catch (Dali::DaliException e) {
44716       {
44717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44718       };
44719     } catch (...) {
44720       {
44721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44722       };
44723     }
44724   }
44725
44726   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44727   return jresult;
44728 }
44729
44730
44731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
44732   void * jresult ;
44733   Dali::BaseHandle arg1 ;
44734   Dali::BaseHandle *argp1 ;
44735   Dali::CameraActor result;
44736
44737   argp1 = (Dali::BaseHandle *)jarg1;
44738   if (!argp1) {
44739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44740     return 0;
44741   }
44742   arg1 = *argp1;
44743   {
44744     try {
44745       result = Dali::CameraActor::DownCast(arg1);
44746     } catch (std::out_of_range& e) {
44747       {
44748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44749       };
44750     } catch (std::exception& e) {
44751       {
44752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44753       };
44754     } catch (Dali::DaliException e) {
44755       {
44756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44757       };
44758     } catch (...) {
44759       {
44760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44761       };
44762     }
44763   }
44764
44765   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44766   return jresult;
44767 }
44768
44769
44770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
44771   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44772
44773   arg1 = (Dali::CameraActor *)jarg1;
44774   {
44775     try {
44776       delete arg1;
44777     } catch (std::out_of_range& e) {
44778       {
44779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44780       };
44781     } catch (std::exception& e) {
44782       {
44783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44784       };
44785     } catch (Dali::DaliException e) {
44786       {
44787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44788       };
44789     } catch (...) {
44790       {
44791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44792       };
44793     }
44794   }
44795
44796 }
44797
44798
44799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
44800   void * jresult ;
44801   Dali::CameraActor *arg1 = 0 ;
44802   Dali::CameraActor *result = 0 ;
44803
44804   arg1 = (Dali::CameraActor *)jarg1;
44805   if (!arg1) {
44806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44807     return 0;
44808   }
44809   {
44810     try {
44811       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
44812     } catch (std::out_of_range& e) {
44813       {
44814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44815       };
44816     } catch (std::exception& e) {
44817       {
44818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44819       };
44820     } catch (Dali::DaliException e) {
44821       {
44822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44823       };
44824     } catch (...) {
44825       {
44826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44827       };
44828     }
44829   }
44830
44831   jresult = (void *)result;
44832   return jresult;
44833 }
44834
44835
44836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
44837   void * jresult ;
44838   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44839   Dali::CameraActor *arg2 = 0 ;
44840   Dali::CameraActor *result = 0 ;
44841
44842   arg1 = (Dali::CameraActor *)jarg1;
44843   arg2 = (Dali::CameraActor *)jarg2;
44844   if (!arg2) {
44845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44846     return 0;
44847   }
44848   {
44849     try {
44850       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
44851     } catch (std::out_of_range& e) {
44852       {
44853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44854       };
44855     } catch (std::exception& e) {
44856       {
44857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44858       };
44859     } catch (Dali::DaliException e) {
44860       {
44861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44862       };
44863     } catch (...) {
44864       {
44865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44866       };
44867     }
44868   }
44869
44870   jresult = (void *)result;
44871   return jresult;
44872 }
44873
44874
44875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
44876   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44877   Dali::Camera::Type arg2 ;
44878
44879   arg1 = (Dali::CameraActor *)jarg1;
44880   arg2 = (Dali::Camera::Type)jarg2;
44881   {
44882     try {
44883       (arg1)->SetType(arg2);
44884     } catch (std::out_of_range& e) {
44885       {
44886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44887       };
44888     } catch (std::exception& e) {
44889       {
44890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44891       };
44892     } catch (Dali::DaliException e) {
44893       {
44894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44895       };
44896     } catch (...) {
44897       {
44898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44899       };
44900     }
44901   }
44902
44903 }
44904
44905
44906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
44907   int jresult ;
44908   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44909   Dali::Camera::Type result;
44910
44911   arg1 = (Dali::CameraActor *)jarg1;
44912   {
44913     try {
44914       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
44915     } catch (std::out_of_range& e) {
44916       {
44917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44918       };
44919     } catch (std::exception& e) {
44920       {
44921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44922       };
44923     } catch (Dali::DaliException e) {
44924       {
44925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44926       };
44927     } catch (...) {
44928       {
44929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44930       };
44931     }
44932   }
44933
44934   jresult = (int)result;
44935   return jresult;
44936 }
44937
44938
44939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
44940   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44941   Dali::Camera::ProjectionMode arg2 ;
44942
44943   arg1 = (Dali::CameraActor *)jarg1;
44944   arg2 = (Dali::Camera::ProjectionMode)jarg2;
44945   {
44946     try {
44947       (arg1)->SetProjectionMode(arg2);
44948     } catch (std::out_of_range& e) {
44949       {
44950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44951       };
44952     } catch (std::exception& e) {
44953       {
44954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44955       };
44956     } catch (Dali::DaliException e) {
44957       {
44958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44959       };
44960     } catch (...) {
44961       {
44962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44963       };
44964     }
44965   }
44966
44967 }
44968
44969
44970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
44971   int jresult ;
44972   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44973   Dali::Camera::ProjectionMode result;
44974
44975   arg1 = (Dali::CameraActor *)jarg1;
44976   {
44977     try {
44978       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
44979     } catch (std::out_of_range& e) {
44980       {
44981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44982       };
44983     } catch (std::exception& e) {
44984       {
44985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44986       };
44987     } catch (Dali::DaliException e) {
44988       {
44989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44990       };
44991     } catch (...) {
44992       {
44993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44994       };
44995     }
44996   }
44997
44998   jresult = (int)result;
44999   return jresult;
45000 }
45001
45002
45003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
45004   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45005   float arg2 ;
45006
45007   arg1 = (Dali::CameraActor *)jarg1;
45008   arg2 = (float)jarg2;
45009   {
45010     try {
45011       (arg1)->SetFieldOfView(arg2);
45012     } catch (std::out_of_range& e) {
45013       {
45014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45015       };
45016     } catch (std::exception& e) {
45017       {
45018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45019       };
45020     } catch (Dali::DaliException e) {
45021       {
45022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45023       };
45024     } catch (...) {
45025       {
45026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45027       };
45028     }
45029   }
45030
45031 }
45032
45033
45034 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
45035   float jresult ;
45036   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45037   float result;
45038
45039   arg1 = (Dali::CameraActor *)jarg1;
45040   {
45041     try {
45042       result = (float)(arg1)->GetFieldOfView();
45043     } catch (std::out_of_range& e) {
45044       {
45045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45046       };
45047     } catch (std::exception& e) {
45048       {
45049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45050       };
45051     } catch (Dali::DaliException e) {
45052       {
45053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45054       };
45055     } catch (...) {
45056       {
45057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45058       };
45059     }
45060   }
45061
45062   jresult = result;
45063   return jresult;
45064 }
45065
45066
45067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
45068   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45069   float arg2 ;
45070
45071   arg1 = (Dali::CameraActor *)jarg1;
45072   arg2 = (float)jarg2;
45073   {
45074     try {
45075       (arg1)->SetAspectRatio(arg2);
45076     } catch (std::out_of_range& e) {
45077       {
45078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45079       };
45080     } catch (std::exception& e) {
45081       {
45082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45083       };
45084     } catch (Dali::DaliException e) {
45085       {
45086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45087       };
45088     } catch (...) {
45089       {
45090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45091       };
45092     }
45093   }
45094
45095 }
45096
45097
45098 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
45099   float jresult ;
45100   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45101   float result;
45102
45103   arg1 = (Dali::CameraActor *)jarg1;
45104   {
45105     try {
45106       result = (float)(arg1)->GetAspectRatio();
45107     } catch (std::out_of_range& e) {
45108       {
45109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45110       };
45111     } catch (std::exception& e) {
45112       {
45113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45114       };
45115     } catch (Dali::DaliException e) {
45116       {
45117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45118       };
45119     } catch (...) {
45120       {
45121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45122       };
45123     }
45124   }
45125
45126   jresult = result;
45127   return jresult;
45128 }
45129
45130
45131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
45132   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45133   float arg2 ;
45134
45135   arg1 = (Dali::CameraActor *)jarg1;
45136   arg2 = (float)jarg2;
45137   {
45138     try {
45139       (arg1)->SetNearClippingPlane(arg2);
45140     } catch (std::out_of_range& e) {
45141       {
45142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45143       };
45144     } catch (std::exception& e) {
45145       {
45146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45147       };
45148     } catch (Dali::DaliException e) {
45149       {
45150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45151       };
45152     } catch (...) {
45153       {
45154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45155       };
45156     }
45157   }
45158
45159 }
45160
45161
45162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
45163   float jresult ;
45164   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45165   float result;
45166
45167   arg1 = (Dali::CameraActor *)jarg1;
45168   {
45169     try {
45170       result = (float)(arg1)->GetNearClippingPlane();
45171     } catch (std::out_of_range& e) {
45172       {
45173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45174       };
45175     } catch (std::exception& e) {
45176       {
45177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45178       };
45179     } catch (Dali::DaliException e) {
45180       {
45181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45182       };
45183     } catch (...) {
45184       {
45185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45186       };
45187     }
45188   }
45189
45190   jresult = result;
45191   return jresult;
45192 }
45193
45194
45195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
45196   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45197   float arg2 ;
45198
45199   arg1 = (Dali::CameraActor *)jarg1;
45200   arg2 = (float)jarg2;
45201   {
45202     try {
45203       (arg1)->SetFarClippingPlane(arg2);
45204     } catch (std::out_of_range& e) {
45205       {
45206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45207       };
45208     } catch (std::exception& e) {
45209       {
45210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45211       };
45212     } catch (Dali::DaliException e) {
45213       {
45214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45215       };
45216     } catch (...) {
45217       {
45218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45219       };
45220     }
45221   }
45222
45223 }
45224
45225
45226 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
45227   float jresult ;
45228   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45229   float result;
45230
45231   arg1 = (Dali::CameraActor *)jarg1;
45232   {
45233     try {
45234       result = (float)(arg1)->GetFarClippingPlane();
45235     } catch (std::out_of_range& e) {
45236       {
45237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45238       };
45239     } catch (std::exception& e) {
45240       {
45241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45242       };
45243     } catch (Dali::DaliException e) {
45244       {
45245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45246       };
45247     } catch (...) {
45248       {
45249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45250       };
45251     }
45252   }
45253
45254   jresult = result;
45255   return jresult;
45256 }
45257
45258
45259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
45260   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45261   Dali::Vector3 *arg2 = 0 ;
45262
45263   arg1 = (Dali::CameraActor *)jarg1;
45264   arg2 = (Dali::Vector3 *)jarg2;
45265   if (!arg2) {
45266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
45267     return ;
45268   }
45269   {
45270     try {
45271       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
45272     } catch (std::out_of_range& e) {
45273       {
45274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45275       };
45276     } catch (std::exception& e) {
45277       {
45278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45279       };
45280     } catch (Dali::DaliException e) {
45281       {
45282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45283       };
45284     } catch (...) {
45285       {
45286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45287       };
45288     }
45289   }
45290
45291 }
45292
45293
45294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
45295   void * jresult ;
45296   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45297   Dali::Vector3 result;
45298
45299   arg1 = (Dali::CameraActor *)jarg1;
45300   {
45301     try {
45302       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
45303     } catch (std::out_of_range& e) {
45304       {
45305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45306       };
45307     } catch (std::exception& e) {
45308       {
45309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45310       };
45311     } catch (Dali::DaliException e) {
45312       {
45313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45314       };
45315     } catch (...) {
45316       {
45317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45318       };
45319     }
45320   }
45321
45322   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
45323   return jresult;
45324 }
45325
45326
45327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
45328   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45329   bool arg2 ;
45330
45331   arg1 = (Dali::CameraActor *)jarg1;
45332   arg2 = jarg2 ? true : false;
45333   {
45334     try {
45335       (arg1)->SetInvertYAxis(arg2);
45336     } catch (std::out_of_range& e) {
45337       {
45338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45339       };
45340     } catch (std::exception& e) {
45341       {
45342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45343       };
45344     } catch (Dali::DaliException e) {
45345       {
45346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45347       };
45348     } catch (...) {
45349       {
45350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45351       };
45352     }
45353   }
45354
45355 }
45356
45357
45358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
45359   unsigned int jresult ;
45360   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45361   bool result;
45362
45363   arg1 = (Dali::CameraActor *)jarg1;
45364   {
45365     try {
45366       result = (bool)(arg1)->GetInvertYAxis();
45367     } catch (std::out_of_range& e) {
45368       {
45369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45370       };
45371     } catch (std::exception& e) {
45372       {
45373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45374       };
45375     } catch (Dali::DaliException e) {
45376       {
45377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45378       };
45379     } catch (...) {
45380       {
45381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45382       };
45383     }
45384   }
45385
45386   jresult = result;
45387   return jresult;
45388 }
45389
45390
45391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
45392   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45393   Dali::Size *arg2 = 0 ;
45394
45395   arg1 = (Dali::CameraActor *)jarg1;
45396   arg2 = (Dali::Size *)jarg2;
45397   if (!arg2) {
45398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45399     return ;
45400   }
45401   {
45402     try {
45403       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
45404     } catch (std::out_of_range& e) {
45405       {
45406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45407       };
45408     } catch (std::exception& e) {
45409       {
45410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45411       };
45412     } catch (Dali::DaliException e) {
45413       {
45414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45415       };
45416     } catch (...) {
45417       {
45418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45419       };
45420     }
45421   }
45422
45423 }
45424
45425
45426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
45427   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45428   Dali::Size *arg2 = 0 ;
45429
45430   arg1 = (Dali::CameraActor *)jarg1;
45431   arg2 = (Dali::Size *)jarg2;
45432   if (!arg2) {
45433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45434     return ;
45435   }
45436   {
45437     try {
45438       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
45439     } catch (std::out_of_range& e) {
45440       {
45441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45442       };
45443     } catch (std::exception& e) {
45444       {
45445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45446       };
45447     } catch (Dali::DaliException e) {
45448       {
45449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45450       };
45451     } catch (...) {
45452       {
45453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45454       };
45455     }
45456   }
45457
45458 }
45459
45460
45461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
45462   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45463   float arg2 ;
45464   float arg3 ;
45465   float arg4 ;
45466   float arg5 ;
45467   float arg6 ;
45468   float arg7 ;
45469
45470   arg1 = (Dali::CameraActor *)jarg1;
45471   arg2 = (float)jarg2;
45472   arg3 = (float)jarg3;
45473   arg4 = (float)jarg4;
45474   arg5 = (float)jarg5;
45475   arg6 = (float)jarg6;
45476   arg7 = (float)jarg7;
45477   {
45478     try {
45479       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
45480     } catch (std::out_of_range& e) {
45481       {
45482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45483       };
45484     } catch (std::exception& e) {
45485       {
45486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45487       };
45488     } catch (Dali::DaliException e) {
45489       {
45490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45491       };
45492     } catch (...) {
45493       {
45494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45495       };
45496     }
45497   }
45498
45499 }
45500
45501
45502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
45503   void * jresult ;
45504   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45505
45506   {
45507     try {
45508       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
45509     } catch (std::out_of_range& e) {
45510       {
45511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45512       };
45513     } catch (std::exception& e) {
45514       {
45515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45516       };
45517     } catch (Dali::DaliException e) {
45518       {
45519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45520       };
45521     } catch (...) {
45522       {
45523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45524       };
45525     }
45526   }
45527
45528   jresult = (void *)result;
45529   return jresult;
45530 }
45531
45532
45533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
45534   void * jresult ;
45535   std::string arg1 ;
45536   Dali::Property::Value arg2 ;
45537   Dali::Property::Value *argp2 ;
45538   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45539
45540   if (!jarg1) {
45541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45542     return 0;
45543   }
45544   (&arg1)->assign(jarg1);
45545   argp2 = (Dali::Property::Value *)jarg2;
45546   if (!argp2) {
45547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
45548     return 0;
45549   }
45550   arg2 = *argp2;
45551   {
45552     try {
45553       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
45554     } catch (std::out_of_range& e) {
45555       {
45556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45557       };
45558     } catch (std::exception& e) {
45559       {
45560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45561       };
45562     } catch (Dali::DaliException e) {
45563       {
45564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45565       };
45566     } catch (...) {
45567       {
45568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45569       };
45570     }
45571   }
45572
45573   jresult = (void *)result;
45574   return jresult;
45575 }
45576
45577
45578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
45579   void * jresult ;
45580   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
45581   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45582
45583   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45584   if (!arg1) {
45585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
45586     return 0;
45587   }
45588   {
45589     try {
45590       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);
45591     } catch (std::out_of_range& e) {
45592       {
45593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45594       };
45595     } catch (std::exception& e) {
45596       {
45597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45598       };
45599     } catch (Dali::DaliException e) {
45600       {
45601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45602       };
45603     } catch (...) {
45604       {
45605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45606       };
45607     }
45608   }
45609
45610   jresult = (void *)result;
45611   return jresult;
45612 }
45613
45614
45615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
45616   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45617   std::string *arg2 = 0 ;
45618
45619   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45620   if (!jarg2) {
45621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45622     return ;
45623   }
45624   std::string arg2_str(jarg2);
45625   arg2 = &arg2_str;
45626   if (arg1) (arg1)->first = *arg2;
45627
45628   //argout typemap for const std::string&
45629
45630 }
45631
45632
45633 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
45634   char * jresult ;
45635   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45636   std::string *result = 0 ;
45637
45638   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45639   result = (std::string *) & ((arg1)->first);
45640   jresult = SWIG_csharp_string_callback(result->c_str());
45641   return jresult;
45642 }
45643
45644
45645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
45646   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45647   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
45648
45649   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45650   arg2 = (Dali::Property::Value *)jarg2;
45651   if (arg1) (arg1)->second = *arg2;
45652 }
45653
45654
45655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
45656   void * jresult ;
45657   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45658   Dali::Property::Value *result = 0 ;
45659
45660   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45661   result = (Dali::Property::Value *)& ((arg1)->second);
45662   jresult = (void *)result;
45663   return jresult;
45664 }
45665
45666
45667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
45668   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45669
45670   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45671   {
45672     try {
45673       delete arg1;
45674     } catch (std::out_of_range& e) {
45675       {
45676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45677       };
45678     } catch (std::exception& e) {
45679       {
45680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45681       };
45682     } catch (Dali::DaliException e) {
45683       {
45684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45685       };
45686     } catch (...) {
45687       {
45688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45689       };
45690     }
45691   }
45692
45693 }
45694
45695
45696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
45697   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45698
45699   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45700   {
45701     try {
45702       (arg1)->clear();
45703     } catch (std::out_of_range& e) {
45704       {
45705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45706       };
45707     } catch (std::exception& e) {
45708       {
45709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45710       };
45711     } catch (Dali::DaliException e) {
45712       {
45713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45714       };
45715     } catch (...) {
45716       {
45717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45718       };
45719     }
45720   }
45721
45722 }
45723
45724
45725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
45726   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45727   Dali::TouchPoint *arg2 = 0 ;
45728
45729   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45730   arg2 = (Dali::TouchPoint *)jarg2;
45731   if (!arg2) {
45732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45733     return ;
45734   }
45735   {
45736     try {
45737       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
45738     } catch (std::out_of_range& e) {
45739       {
45740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45741       };
45742     } catch (std::exception& e) {
45743       {
45744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45745       };
45746     } catch (Dali::DaliException e) {
45747       {
45748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45749       };
45750     } catch (...) {
45751       {
45752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45753       };
45754     }
45755   }
45756
45757 }
45758
45759
45760 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
45761   unsigned long jresult ;
45762   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45763   std::vector< Dali::TouchPoint >::size_type result;
45764
45765   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45766   {
45767     try {
45768       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
45769     } catch (std::out_of_range& e) {
45770       {
45771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45772       };
45773     } catch (std::exception& e) {
45774       {
45775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45776       };
45777     } catch (Dali::DaliException e) {
45778       {
45779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45780       };
45781     } catch (...) {
45782       {
45783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45784       };
45785     }
45786   }
45787
45788   jresult = (unsigned long)result;
45789   return jresult;
45790 }
45791
45792
45793 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
45794   unsigned long jresult ;
45795   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45796   std::vector< Dali::TouchPoint >::size_type result;
45797
45798   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45799   {
45800     try {
45801       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
45802     } catch (std::out_of_range& e) {
45803       {
45804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45805       };
45806     } catch (std::exception& e) {
45807       {
45808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45809       };
45810     } catch (Dali::DaliException e) {
45811       {
45812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45813       };
45814     } catch (...) {
45815       {
45816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45817       };
45818     }
45819   }
45820
45821   jresult = (unsigned long)result;
45822   return jresult;
45823 }
45824
45825
45826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
45827   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45828   std::vector< Dali::TouchPoint >::size_type arg2 ;
45829
45830   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45831   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
45832   {
45833     try {
45834       (arg1)->reserve(arg2);
45835     } catch (std::out_of_range& e) {
45836       {
45837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45838       };
45839     } catch (std::exception& e) {
45840       {
45841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45842       };
45843     } catch (Dali::DaliException e) {
45844       {
45845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45846       };
45847     } catch (...) {
45848       {
45849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45850       };
45851     }
45852   }
45853
45854 }
45855
45856
45857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
45858   void * jresult ;
45859   std::vector< Dali::TouchPoint > *result = 0 ;
45860
45861   {
45862     try {
45863       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
45864     } catch (std::out_of_range& e) {
45865       {
45866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45867       };
45868     } catch (std::exception& e) {
45869       {
45870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45871       };
45872     } catch (Dali::DaliException e) {
45873       {
45874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45875       };
45876     } catch (...) {
45877       {
45878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45879       };
45880     }
45881   }
45882
45883   jresult = (void *)result;
45884   return jresult;
45885 }
45886
45887
45888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
45889   void * jresult ;
45890   std::vector< Dali::TouchPoint > *arg1 = 0 ;
45891   std::vector< Dali::TouchPoint > *result = 0 ;
45892
45893   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45894   if (!arg1) {
45895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45896     return 0;
45897   }
45898   {
45899     try {
45900       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
45901     } catch (std::out_of_range& e) {
45902       {
45903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45904       };
45905     } catch (std::exception& e) {
45906       {
45907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45908       };
45909     } catch (Dali::DaliException e) {
45910       {
45911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45912       };
45913     } catch (...) {
45914       {
45915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45916       };
45917     }
45918   }
45919
45920   jresult = (void *)result;
45921   return jresult;
45922 }
45923
45924
45925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
45926   void * jresult ;
45927   int arg1 ;
45928   std::vector< Dali::TouchPoint > *result = 0 ;
45929
45930   arg1 = (int)jarg1;
45931   {
45932     try {
45933       try {
45934         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
45935       }
45936       catch(std::out_of_range &_e) {
45937         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45938         return 0;
45939       }
45940
45941     } catch (std::out_of_range& e) {
45942       {
45943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45944       };
45945     } catch (std::exception& e) {
45946       {
45947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45948       };
45949     } catch (Dali::DaliException e) {
45950       {
45951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45952       };
45953     } catch (...) {
45954       {
45955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45956       };
45957     }
45958   }
45959
45960   jresult = (void *)result;
45961   return jresult;
45962 }
45963
45964
45965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
45966   void * jresult ;
45967   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45968   int arg2 ;
45969   SwigValueWrapper< Dali::TouchPoint > result;
45970
45971   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45972   arg2 = (int)jarg2;
45973   {
45974     try {
45975       try {
45976         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
45977       }
45978       catch(std::out_of_range &_e) {
45979         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45980         return 0;
45981       }
45982
45983     } catch (std::out_of_range& e) {
45984       {
45985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45986       };
45987     } catch (std::exception& e) {
45988       {
45989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45990       };
45991     } catch (Dali::DaliException e) {
45992       {
45993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45994       };
45995     } catch (...) {
45996       {
45997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45998       };
45999     }
46000   }
46001
46002   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
46003   return jresult;
46004 }
46005
46006
46007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
46008   void * jresult ;
46009   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46010   int arg2 ;
46011   Dali::TouchPoint *result = 0 ;
46012
46013   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46014   arg2 = (int)jarg2;
46015   {
46016     try {
46017       try {
46018         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
46019       }
46020       catch(std::out_of_range &_e) {
46021         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46022         return 0;
46023       }
46024
46025     } catch (std::out_of_range& e) {
46026       {
46027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46028       };
46029     } catch (std::exception& e) {
46030       {
46031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46032       };
46033     } catch (Dali::DaliException e) {
46034       {
46035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46036       };
46037     } catch (...) {
46038       {
46039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46040       };
46041     }
46042   }
46043
46044   jresult = (void *)result;
46045   return jresult;
46046 }
46047
46048
46049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
46050   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46051   int arg2 ;
46052   Dali::TouchPoint *arg3 = 0 ;
46053
46054   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46055   arg2 = (int)jarg2;
46056   arg3 = (Dali::TouchPoint *)jarg3;
46057   if (!arg3) {
46058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46059     return ;
46060   }
46061   {
46062     try {
46063       try {
46064         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46065       }
46066       catch(std::out_of_range &_e) {
46067         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46068         return ;
46069       }
46070
46071     } catch (std::out_of_range& e) {
46072       {
46073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46074       };
46075     } catch (std::exception& e) {
46076       {
46077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46078       };
46079     } catch (Dali::DaliException e) {
46080       {
46081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46082       };
46083     } catch (...) {
46084       {
46085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46086       };
46087     }
46088   }
46089
46090 }
46091
46092
46093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
46094   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46095   std::vector< Dali::TouchPoint > *arg2 = 0 ;
46096
46097   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46098   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
46099   if (!arg2) {
46100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46101     return ;
46102   }
46103   {
46104     try {
46105       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
46106     } catch (std::out_of_range& e) {
46107       {
46108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46109       };
46110     } catch (std::exception& e) {
46111       {
46112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46113       };
46114     } catch (Dali::DaliException e) {
46115       {
46116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46117       };
46118     } catch (...) {
46119       {
46120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46121       };
46122     }
46123   }
46124
46125 }
46126
46127
46128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
46129   void * jresult ;
46130   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46131   int arg2 ;
46132   int arg3 ;
46133   std::vector< Dali::TouchPoint > *result = 0 ;
46134
46135   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46136   arg2 = (int)jarg2;
46137   arg3 = (int)jarg3;
46138   {
46139     try {
46140       try {
46141         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
46142       }
46143       catch(std::out_of_range &_e) {
46144         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46145         return 0;
46146       }
46147       catch(std::invalid_argument &_e) {
46148         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46149         return 0;
46150       }
46151
46152     } catch (std::out_of_range& e) {
46153       {
46154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46155       };
46156     } catch (std::exception& e) {
46157       {
46158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46159       };
46160     } catch (Dali::DaliException e) {
46161       {
46162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46163       };
46164     } catch (...) {
46165       {
46166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46167       };
46168     }
46169   }
46170
46171   jresult = (void *)result;
46172   return jresult;
46173 }
46174
46175
46176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
46177   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46178   int arg2 ;
46179   Dali::TouchPoint *arg3 = 0 ;
46180
46181   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46182   arg2 = (int)jarg2;
46183   arg3 = (Dali::TouchPoint *)jarg3;
46184   if (!arg3) {
46185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46186     return ;
46187   }
46188   {
46189     try {
46190       try {
46191         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46192       }
46193       catch(std::out_of_range &_e) {
46194         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46195         return ;
46196       }
46197
46198     } catch (std::out_of_range& e) {
46199       {
46200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46201       };
46202     } catch (std::exception& e) {
46203       {
46204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46205       };
46206     } catch (Dali::DaliException e) {
46207       {
46208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46209       };
46210     } catch (...) {
46211       {
46212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46213       };
46214     }
46215   }
46216
46217 }
46218
46219
46220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
46221   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46222   int arg2 ;
46223   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46224
46225   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46226   arg2 = (int)jarg2;
46227   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46228   if (!arg3) {
46229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46230     return ;
46231   }
46232   {
46233     try {
46234       try {
46235         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46236       }
46237       catch(std::out_of_range &_e) {
46238         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46239         return ;
46240       }
46241
46242     } catch (std::out_of_range& e) {
46243       {
46244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46245       };
46246     } catch (std::exception& e) {
46247       {
46248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46249       };
46250     } catch (Dali::DaliException e) {
46251       {
46252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46253       };
46254     } catch (...) {
46255       {
46256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46257       };
46258     }
46259   }
46260
46261 }
46262
46263
46264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
46265   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46266   int arg2 ;
46267
46268   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46269   arg2 = (int)jarg2;
46270   {
46271     try {
46272       try {
46273         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
46274       }
46275       catch(std::out_of_range &_e) {
46276         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46277         return ;
46278       }
46279
46280     } catch (std::out_of_range& e) {
46281       {
46282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46283       };
46284     } catch (std::exception& e) {
46285       {
46286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46287       };
46288     } catch (Dali::DaliException e) {
46289       {
46290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46291       };
46292     } catch (...) {
46293       {
46294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46295       };
46296     }
46297   }
46298
46299 }
46300
46301
46302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
46303   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46304   int arg2 ;
46305   int arg3 ;
46306
46307   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46308   arg2 = (int)jarg2;
46309   arg3 = (int)jarg3;
46310   {
46311     try {
46312       try {
46313         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
46314       }
46315       catch(std::out_of_range &_e) {
46316         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46317         return ;
46318       }
46319       catch(std::invalid_argument &_e) {
46320         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46321         return ;
46322       }
46323
46324     } catch (std::out_of_range& e) {
46325       {
46326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46327       };
46328     } catch (std::exception& e) {
46329       {
46330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46331       };
46332     } catch (Dali::DaliException e) {
46333       {
46334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46335       };
46336     } catch (...) {
46337       {
46338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46339       };
46340     }
46341   }
46342
46343 }
46344
46345
46346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
46347   void * jresult ;
46348   Dali::TouchPoint *arg1 = 0 ;
46349   int arg2 ;
46350   std::vector< Dali::TouchPoint > *result = 0 ;
46351
46352   arg1 = (Dali::TouchPoint *)jarg1;
46353   if (!arg1) {
46354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46355     return 0;
46356   }
46357   arg2 = (int)jarg2;
46358   {
46359     try {
46360       try {
46361         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
46362       }
46363       catch(std::out_of_range &_e) {
46364         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46365         return 0;
46366       }
46367
46368     } catch (std::out_of_range& e) {
46369       {
46370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46371       };
46372     } catch (std::exception& e) {
46373       {
46374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46375       };
46376     } catch (Dali::DaliException e) {
46377       {
46378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46379       };
46380     } catch (...) {
46381       {
46382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46383       };
46384     }
46385   }
46386
46387   jresult = (void *)result;
46388   return jresult;
46389 }
46390
46391
46392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
46393   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46394
46395   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46396   {
46397     try {
46398       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
46399     } catch (std::out_of_range& e) {
46400       {
46401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46402       };
46403     } catch (std::exception& e) {
46404       {
46405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46406       };
46407     } catch (Dali::DaliException e) {
46408       {
46409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46410       };
46411     } catch (...) {
46412       {
46413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46414       };
46415     }
46416   }
46417
46418 }
46419
46420
46421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
46422   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46423   int arg2 ;
46424   int arg3 ;
46425
46426   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46427   arg2 = (int)jarg2;
46428   arg3 = (int)jarg3;
46429   {
46430     try {
46431       try {
46432         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
46433       }
46434       catch(std::out_of_range &_e) {
46435         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46436         return ;
46437       }
46438       catch(std::invalid_argument &_e) {
46439         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46440         return ;
46441       }
46442
46443     } catch (std::out_of_range& e) {
46444       {
46445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46446       };
46447     } catch (std::exception& e) {
46448       {
46449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46450       };
46451     } catch (Dali::DaliException e) {
46452       {
46453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46454       };
46455     } catch (...) {
46456       {
46457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46458       };
46459     }
46460   }
46461
46462 }
46463
46464
46465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
46466   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46467   int arg2 ;
46468   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46469
46470   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46471   arg2 = (int)jarg2;
46472   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46473   if (!arg3) {
46474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46475     return ;
46476   }
46477   {
46478     try {
46479       try {
46480         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46481       }
46482       catch(std::out_of_range &_e) {
46483         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46484         return ;
46485       }
46486
46487     } catch (std::out_of_range& e) {
46488       {
46489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46490       };
46491     } catch (std::exception& e) {
46492       {
46493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46494       };
46495     } catch (Dali::DaliException e) {
46496       {
46497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46498       };
46499     } catch (...) {
46500       {
46501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46502       };
46503     }
46504   }
46505
46506 }
46507
46508
46509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
46510   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46511
46512   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46513   {
46514     try {
46515       delete arg1;
46516     } catch (std::out_of_range& e) {
46517       {
46518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46519       };
46520     } catch (std::exception& e) {
46521       {
46522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46523       };
46524     } catch (Dali::DaliException e) {
46525       {
46526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46527       };
46528     } catch (...) {
46529       {
46530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46531       };
46532     }
46533   }
46534
46535 }
46536
46537
46538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
46539   void * jresult ;
46540   Dali::Rect< int > *result = 0 ;
46541
46542   {
46543     try {
46544       result = (Dali::Rect< int > *)new Dali::Rect< int >();
46545     } catch (std::out_of_range& e) {
46546       {
46547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46548       };
46549     } catch (std::exception& e) {
46550       {
46551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46552       };
46553     } catch (Dali::DaliException e) {
46554       {
46555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46556       };
46557     } catch (...) {
46558       {
46559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46560       };
46561     }
46562   }
46563
46564   jresult = (void *)result;
46565   return jresult;
46566 }
46567
46568
46569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
46570   void * jresult ;
46571   int arg1 ;
46572   int arg2 ;
46573   int arg3 ;
46574   int arg4 ;
46575   Dali::Rect< int > *result = 0 ;
46576
46577   arg1 = (int)jarg1;
46578   arg2 = (int)jarg2;
46579   arg3 = (int)jarg3;
46580   arg4 = (int)jarg4;
46581   {
46582     try {
46583       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
46584     } catch (std::out_of_range& e) {
46585       {
46586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46587       };
46588     } catch (std::exception& e) {
46589       {
46590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46591       };
46592     } catch (Dali::DaliException e) {
46593       {
46594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46595       };
46596     } catch (...) {
46597       {
46598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46599       };
46600     }
46601   }
46602
46603   jresult = (void *)result;
46604   return jresult;
46605 }
46606
46607
46608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
46609   void * jresult ;
46610   Dali::Rect< int > *arg1 = 0 ;
46611   Dali::Rect< int > *result = 0 ;
46612
46613   arg1 = (Dali::Rect< int > *)jarg1;
46614   if (!arg1) {
46615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46616     return 0;
46617   }
46618   {
46619     try {
46620       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
46621     } catch (std::out_of_range& e) {
46622       {
46623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46624       };
46625     } catch (std::exception& e) {
46626       {
46627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46628       };
46629     } catch (Dali::DaliException e) {
46630       {
46631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46632       };
46633     } catch (...) {
46634       {
46635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46636       };
46637     }
46638   }
46639
46640   jresult = (void *)result;
46641   return jresult;
46642 }
46643
46644
46645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
46646   void * jresult ;
46647   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46648   Dali::Rect< int > *arg2 = 0 ;
46649   Dali::Rect< int > *result = 0 ;
46650
46651   arg1 = (Dali::Rect< int > *)jarg1;
46652   arg2 = (Dali::Rect< int > *)jarg2;
46653   if (!arg2) {
46654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46655     return 0;
46656   }
46657   {
46658     try {
46659       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
46660     } catch (std::out_of_range& e) {
46661       {
46662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46663       };
46664     } catch (std::exception& e) {
46665       {
46666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46667       };
46668     } catch (Dali::DaliException e) {
46669       {
46670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46671       };
46672     } catch (...) {
46673       {
46674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46675       };
46676     }
46677   }
46678
46679   jresult = (void *)result;
46680   return jresult;
46681 }
46682
46683
46684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
46685   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46686   int arg2 ;
46687   int arg3 ;
46688   int arg4 ;
46689   int arg5 ;
46690
46691   arg1 = (Dali::Rect< int > *)jarg1;
46692   arg2 = (int)jarg2;
46693   arg3 = (int)jarg3;
46694   arg4 = (int)jarg4;
46695   arg5 = (int)jarg5;
46696   {
46697     try {
46698       (arg1)->Set(arg2,arg3,arg4,arg5);
46699     } catch (std::out_of_range& e) {
46700       {
46701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46702       };
46703     } catch (std::exception& e) {
46704       {
46705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46706       };
46707     } catch (Dali::DaliException e) {
46708       {
46709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46710       };
46711     } catch (...) {
46712       {
46713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46714       };
46715     }
46716   }
46717
46718 }
46719
46720
46721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
46722   unsigned int jresult ;
46723   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46724   bool result;
46725
46726   arg1 = (Dali::Rect< int > *)jarg1;
46727   {
46728     try {
46729       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
46730     } catch (std::out_of_range& e) {
46731       {
46732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46733       };
46734     } catch (std::exception& e) {
46735       {
46736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46737       };
46738     } catch (Dali::DaliException e) {
46739       {
46740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46741       };
46742     } catch (...) {
46743       {
46744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46745       };
46746     }
46747   }
46748
46749   jresult = result;
46750   return jresult;
46751 }
46752
46753
46754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
46755   int jresult ;
46756   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46757   int result;
46758
46759   arg1 = (Dali::Rect< int > *)jarg1;
46760   {
46761     try {
46762       result = (int)((Dali::Rect< int > const *)arg1)->Left();
46763     } catch (std::out_of_range& e) {
46764       {
46765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46766       };
46767     } catch (std::exception& e) {
46768       {
46769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46770       };
46771     } catch (Dali::DaliException e) {
46772       {
46773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46774       };
46775     } catch (...) {
46776       {
46777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46778       };
46779     }
46780   }
46781
46782   jresult = result;
46783   return jresult;
46784 }
46785
46786
46787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
46788   int jresult ;
46789   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46790   int result;
46791
46792   arg1 = (Dali::Rect< int > *)jarg1;
46793   {
46794     try {
46795       result = (int)((Dali::Rect< int > const *)arg1)->Right();
46796     } catch (std::out_of_range& e) {
46797       {
46798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46799       };
46800     } catch (std::exception& e) {
46801       {
46802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46803       };
46804     } catch (Dali::DaliException e) {
46805       {
46806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46807       };
46808     } catch (...) {
46809       {
46810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46811       };
46812     }
46813   }
46814
46815   jresult = result;
46816   return jresult;
46817 }
46818
46819
46820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
46821   int jresult ;
46822   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46823   int result;
46824
46825   arg1 = (Dali::Rect< int > *)jarg1;
46826   {
46827     try {
46828       result = (int)((Dali::Rect< int > const *)arg1)->Top();
46829     } catch (std::out_of_range& e) {
46830       {
46831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46832       };
46833     } catch (std::exception& e) {
46834       {
46835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46836       };
46837     } catch (Dali::DaliException e) {
46838       {
46839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46840       };
46841     } catch (...) {
46842       {
46843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46844       };
46845     }
46846   }
46847
46848   jresult = result;
46849   return jresult;
46850 }
46851
46852
46853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
46854   int jresult ;
46855   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46856   int result;
46857
46858   arg1 = (Dali::Rect< int > *)jarg1;
46859   {
46860     try {
46861       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
46862     } catch (std::out_of_range& e) {
46863       {
46864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46865       };
46866     } catch (std::exception& e) {
46867       {
46868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46869       };
46870     } catch (Dali::DaliException e) {
46871       {
46872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46873       };
46874     } catch (...) {
46875       {
46876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46877       };
46878     }
46879   }
46880
46881   jresult = result;
46882   return jresult;
46883 }
46884
46885
46886 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
46887   int jresult ;
46888   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46889   int result;
46890
46891   arg1 = (Dali::Rect< int > *)jarg1;
46892   {
46893     try {
46894       result = (int)((Dali::Rect< int > const *)arg1)->Area();
46895     } catch (std::out_of_range& e) {
46896       {
46897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46898       };
46899     } catch (std::exception& e) {
46900       {
46901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46902       };
46903     } catch (Dali::DaliException e) {
46904       {
46905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46906       };
46907     } catch (...) {
46908       {
46909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46910       };
46911     }
46912   }
46913
46914   jresult = result;
46915   return jresult;
46916 }
46917
46918
46919 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
46920   unsigned int jresult ;
46921   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46922   Dali::Rect< int > *arg2 = 0 ;
46923   bool result;
46924
46925   arg1 = (Dali::Rect< int > *)jarg1;
46926   arg2 = (Dali::Rect< int > *)jarg2;
46927   if (!arg2) {
46928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46929     return 0;
46930   }
46931   {
46932     try {
46933       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
46934     } catch (std::out_of_range& e) {
46935       {
46936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46937       };
46938     } catch (std::exception& e) {
46939       {
46940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46941       };
46942     } catch (Dali::DaliException e) {
46943       {
46944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46945       };
46946     } catch (...) {
46947       {
46948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46949       };
46950     }
46951   }
46952
46953   jresult = result;
46954   return jresult;
46955 }
46956
46957
46958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
46959   unsigned int jresult ;
46960   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46961   Dali::Rect< int > *arg2 = 0 ;
46962   bool result;
46963
46964   arg1 = (Dali::Rect< int > *)jarg1;
46965   arg2 = (Dali::Rect< int > *)jarg2;
46966   if (!arg2) {
46967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46968     return 0;
46969   }
46970   {
46971     try {
46972       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
46973     } catch (std::out_of_range& e) {
46974       {
46975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46976       };
46977     } catch (std::exception& e) {
46978       {
46979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46980       };
46981     } catch (Dali::DaliException e) {
46982       {
46983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46984       };
46985     } catch (...) {
46986       {
46987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46988       };
46989     }
46990   }
46991
46992   jresult = result;
46993   return jresult;
46994 }
46995
46996
46997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
46998   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46999   int arg2 ;
47000
47001   arg1 = (Dali::Rect< int > *)jarg1;
47002   arg2 = (int)jarg2;
47003   if (arg1) (arg1)->x = arg2;
47004 }
47005
47006
47007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
47008   int jresult ;
47009   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47010   int result;
47011
47012   arg1 = (Dali::Rect< int > *)jarg1;
47013   result = (int) ((arg1)->x);
47014   jresult = result;
47015   return jresult;
47016 }
47017
47018
47019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
47020   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47021   int arg2 ;
47022
47023   arg1 = (Dali::Rect< int > *)jarg1;
47024   arg2 = (int)jarg2;
47025   if (arg1) (arg1)->left = arg2;
47026 }
47027
47028
47029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
47030   int jresult ;
47031   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47032   int result;
47033
47034   arg1 = (Dali::Rect< int > *)jarg1;
47035   result = (int) ((arg1)->left);
47036   jresult = result;
47037   return jresult;
47038 }
47039
47040
47041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
47042   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47043   int arg2 ;
47044
47045   arg1 = (Dali::Rect< int > *)jarg1;
47046   arg2 = (int)jarg2;
47047   if (arg1) (arg1)->y = arg2;
47048 }
47049
47050
47051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
47052   int jresult ;
47053   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47054   int result;
47055
47056   arg1 = (Dali::Rect< int > *)jarg1;
47057   result = (int) ((arg1)->y);
47058   jresult = result;
47059   return jresult;
47060 }
47061
47062
47063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
47064   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47065   int arg2 ;
47066
47067   arg1 = (Dali::Rect< int > *)jarg1;
47068   arg2 = (int)jarg2;
47069   if (arg1) (arg1)->right = arg2;
47070 }
47071
47072
47073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
47074   int jresult ;
47075   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47076   int result;
47077
47078   arg1 = (Dali::Rect< int > *)jarg1;
47079   result = (int) ((arg1)->right);
47080   jresult = result;
47081   return jresult;
47082 }
47083
47084
47085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
47086   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47087   int arg2 ;
47088
47089   arg1 = (Dali::Rect< int > *)jarg1;
47090   arg2 = (int)jarg2;
47091   if (arg1) (arg1)->width = arg2;
47092 }
47093
47094
47095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
47096   int jresult ;
47097   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47098   int result;
47099
47100   arg1 = (Dali::Rect< int > *)jarg1;
47101   result = (int) ((arg1)->width);
47102   jresult = result;
47103   return jresult;
47104 }
47105
47106
47107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
47108   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47109   int arg2 ;
47110
47111   arg1 = (Dali::Rect< int > *)jarg1;
47112   arg2 = (int)jarg2;
47113   if (arg1) (arg1)->bottom = arg2;
47114 }
47115
47116
47117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
47118   int jresult ;
47119   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47120   int result;
47121
47122   arg1 = (Dali::Rect< int > *)jarg1;
47123   result = (int) ((arg1)->bottom);
47124   jresult = result;
47125   return jresult;
47126 }
47127
47128
47129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
47130   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47131   int arg2 ;
47132
47133   arg1 = (Dali::Rect< int > *)jarg1;
47134   arg2 = (int)jarg2;
47135   if (arg1) (arg1)->height = arg2;
47136 }
47137
47138
47139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
47140   int jresult ;
47141   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47142   int result;
47143
47144   arg1 = (Dali::Rect< int > *)jarg1;
47145   result = (int) ((arg1)->height);
47146   jresult = result;
47147   return jresult;
47148 }
47149
47150
47151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
47152   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47153   int arg2 ;
47154
47155   arg1 = (Dali::Rect< int > *)jarg1;
47156   arg2 = (int)jarg2;
47157   if (arg1) (arg1)->top = arg2;
47158 }
47159
47160
47161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
47162   int jresult ;
47163   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47164   int result;
47165
47166   arg1 = (Dali::Rect< int > *)jarg1;
47167   result = (int) ((arg1)->top);
47168   jresult = result;
47169   return jresult;
47170 }
47171
47172
47173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
47174   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47175
47176   arg1 = (Dali::Rect< int > *)jarg1;
47177   {
47178     try {
47179       delete arg1;
47180     } catch (std::out_of_range& e) {
47181       {
47182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47183       };
47184     } catch (std::exception& e) {
47185       {
47186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47187       };
47188     } catch (Dali::DaliException e) {
47189       {
47190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47191       };
47192     } catch (...) {
47193       {
47194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47195       };
47196     }
47197   }
47198
47199 }
47200
47201
47202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
47203   void * jresult ;
47204   Dali::Rect< float > *result = 0 ;
47205
47206   {
47207     try {
47208       result = (Dali::Rect< float > *)new Dali::Rect< float >();
47209     } catch (std::out_of_range& e) {
47210       {
47211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47212       };
47213     } catch (std::exception& e) {
47214       {
47215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47216       };
47217     } catch (Dali::DaliException e) {
47218       {
47219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47220       };
47221     } catch (...) {
47222       {
47223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47224       };
47225     }
47226   }
47227
47228   jresult = (void *)result;
47229   return jresult;
47230 }
47231
47232
47233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
47234   void * jresult ;
47235   float arg1 ;
47236   float arg2 ;
47237   float arg3 ;
47238   float arg4 ;
47239   Dali::Rect< float > *result = 0 ;
47240
47241   arg1 = (float)jarg1;
47242   arg2 = (float)jarg2;
47243   arg3 = (float)jarg4;
47244   arg4 = (float)jarg3;
47245   {
47246     try {
47247       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
47248     } catch (std::out_of_range& e) {
47249       {
47250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47251       };
47252     } catch (std::exception& e) {
47253       {
47254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47255       };
47256     } catch (Dali::DaliException e) {
47257       {
47258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47259       };
47260     } catch (...) {
47261       {
47262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47263       };
47264     }
47265   }
47266
47267   jresult = (void *)result;
47268   return jresult;
47269 }
47270
47271
47272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
47273   void * jresult ;
47274   Dali::Rect< float > *arg1 = 0 ;
47275   Dali::Rect< float > *result = 0 ;
47276
47277   arg1 = (Dali::Rect< float > *)jarg1;
47278   if (!arg1) {
47279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47280     return 0;
47281   }
47282   {
47283     try {
47284       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
47285     } catch (std::out_of_range& e) {
47286       {
47287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47288       };
47289     } catch (std::exception& e) {
47290       {
47291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47292       };
47293     } catch (Dali::DaliException e) {
47294       {
47295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47296       };
47297     } catch (...) {
47298       {
47299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47300       };
47301     }
47302   }
47303
47304   jresult = (void *)result;
47305   return jresult;
47306 }
47307
47308
47309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
47310   void * jresult ;
47311   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47312   Dali::Rect< float > *arg2 = 0 ;
47313   Dali::Rect< float > *result = 0 ;
47314
47315   arg1 = (Dali::Rect< float > *)jarg1;
47316   arg2 = (Dali::Rect< float > *)jarg2;
47317   if (!arg2) {
47318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47319     return 0;
47320   }
47321   {
47322     try {
47323       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
47324     } catch (std::out_of_range& e) {
47325       {
47326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47327       };
47328     } catch (std::exception& e) {
47329       {
47330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47331       };
47332     } catch (Dali::DaliException e) {
47333       {
47334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47335       };
47336     } catch (...) {
47337       {
47338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47339       };
47340     }
47341   }
47342
47343   jresult = (void *)result;
47344   return jresult;
47345 }
47346
47347
47348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
47349   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47350   float arg2 ;
47351   float arg3 ;
47352   float arg4 ;
47353   float arg5 ;
47354
47355   arg1 = (Dali::Rect< float > *)jarg1;
47356   arg2 = (float)jarg2;
47357   arg3 = (float)jarg3;
47358   arg4 = (float)jarg5;
47359   arg5 = (float)jarg4;
47360   {
47361     try {
47362       (arg1)->Set(arg2,arg3,arg4,arg5);
47363     } catch (std::out_of_range& e) {
47364       {
47365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47366       };
47367     } catch (std::exception& e) {
47368       {
47369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47370       };
47371     } catch (Dali::DaliException e) {
47372       {
47373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47374       };
47375     } catch (...) {
47376       {
47377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47378       };
47379     }
47380   }
47381
47382 }
47383
47384
47385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
47386   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47387   float arg2 ;
47388
47389   arg1 = (Dali::Rect< float > *)jarg1;
47390   arg2 = (float)jarg2;
47391   if (arg1) (arg1)->left = arg2;
47392 }
47393
47394
47395 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
47396   float jresult ;
47397   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47398   float result;
47399
47400   arg1 = (Dali::Rect< float > *)jarg1;
47401   result = (float) ((arg1)->left);
47402   jresult = result;
47403   return jresult;
47404 }
47405
47406
47407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
47408   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47409   float arg2 ;
47410
47411   arg1 = (Dali::Rect< float > *)jarg1;
47412   arg2 = (float)jarg2;
47413   if (arg1) (arg1)->left = arg2;
47414 }
47415
47416
47417 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
47418   float jresult ;
47419   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47420   float result;
47421
47422   arg1 = (Dali::Rect< float > *)jarg1;
47423   result = (float) ((arg1)->left);
47424   jresult = result;
47425   return jresult;
47426 }
47427
47428
47429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
47430   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47431   float arg2 ;
47432
47433   arg1 = (Dali::Rect< float > *)jarg1;
47434   arg2 = (float)jarg2;
47435   if (arg1) (arg1)->right = arg2;
47436 }
47437
47438
47439 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
47440   float jresult ;
47441   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47442   float result;
47443
47444   arg1 = (Dali::Rect< float > *)jarg1;
47445   result = (float) ((arg1)->right);
47446   jresult = result;
47447   return jresult;
47448 }
47449
47450
47451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
47452   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47453   float arg2 ;
47454
47455   arg1 = (Dali::Rect< float > *)jarg1;
47456   arg2 = (float)jarg2;
47457   if (arg1) (arg1)->right = arg2;
47458 }
47459
47460
47461 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
47462   float jresult ;
47463   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47464   float result;
47465
47466   arg1 = (Dali::Rect< float > *)jarg1;
47467   result = (float) ((arg1)->right);
47468   jresult = result;
47469   return jresult;
47470 }
47471
47472
47473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
47474   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47475   float arg2 ;
47476
47477   arg1 = (Dali::Rect< float > *)jarg1;
47478   arg2 = (float)jarg2;
47479   if (arg1) (arg1)->bottom = arg2;
47480 }
47481
47482
47483 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
47484   float jresult ;
47485   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47486   float result;
47487
47488   arg1 = (Dali::Rect< float > *)jarg1;
47489   result = (float) ((arg1)->bottom);
47490   jresult = result;
47491   return jresult;
47492 }
47493
47494
47495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
47496   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47497   float arg2 ;
47498
47499   arg1 = (Dali::Rect< float > *)jarg1;
47500   arg2 = (float)jarg2;
47501   if (arg1) (arg1)->top = arg2;
47502 }
47503
47504
47505 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
47506   float jresult ;
47507   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47508   float result;
47509
47510   arg1 = (Dali::Rect< float > *)jarg1;
47511   result = (float) ((arg1)->top);
47512   jresult = result;
47513   return jresult;
47514 }
47515
47516
47517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
47518   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47519
47520   arg1 = (Dali::Rect< float > *)jarg1;
47521   {
47522     try {
47523       delete arg1;
47524     } catch (std::out_of_range& e) {
47525       {
47526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47527       };
47528     } catch (std::exception& e) {
47529       {
47530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47531       };
47532     } catch (Dali::DaliException e) {
47533       {
47534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47535       };
47536     } catch (...) {
47537       {
47538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47539       };
47540     }
47541   }
47542
47543 }
47544
47545
47546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
47547   int jresult ;
47548   int result;
47549
47550   result = (int)Dali::Vector< int >::BaseType;
47551   jresult = (int)result;
47552   return jresult;
47553 }
47554
47555
47556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
47557   void * jresult ;
47558   Dali::Vector< int > *result = 0 ;
47559
47560   {
47561     try {
47562       result = (Dali::Vector< int > *)new Dali::Vector< int >();
47563     } catch (std::out_of_range& e) {
47564       {
47565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47566       };
47567     } catch (std::exception& e) {
47568       {
47569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47570       };
47571     } catch (Dali::DaliException e) {
47572       {
47573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47574       };
47575     } catch (...) {
47576       {
47577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47578       };
47579     }
47580   }
47581
47582   jresult = (void *)result;
47583   return jresult;
47584 }
47585
47586
47587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
47588   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47589
47590   arg1 = (Dali::Vector< int > *)jarg1;
47591   {
47592     try {
47593       delete arg1;
47594     } catch (std::out_of_range& e) {
47595       {
47596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47597       };
47598     } catch (std::exception& e) {
47599       {
47600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47601       };
47602     } catch (Dali::DaliException e) {
47603       {
47604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47605       };
47606     } catch (...) {
47607       {
47608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47609       };
47610     }
47611   }
47612
47613 }
47614
47615
47616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
47617   void * jresult ;
47618   Dali::Vector< int > *arg1 = 0 ;
47619   Dali::Vector< int > *result = 0 ;
47620
47621   arg1 = (Dali::Vector< int > *)jarg1;
47622   if (!arg1) {
47623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47624     return 0;
47625   }
47626   {
47627     try {
47628       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
47629     } catch (std::out_of_range& e) {
47630       {
47631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47632       };
47633     } catch (std::exception& e) {
47634       {
47635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47636       };
47637     } catch (Dali::DaliException e) {
47638       {
47639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47640       };
47641     } catch (...) {
47642       {
47643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47644       };
47645     }
47646   }
47647
47648   jresult = (void *)result;
47649   return jresult;
47650 }
47651
47652
47653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
47654   void * jresult ;
47655   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47656   Dali::Vector< int > *arg2 = 0 ;
47657   Dali::Vector< int > *result = 0 ;
47658
47659   arg1 = (Dali::Vector< int > *)jarg1;
47660   arg2 = (Dali::Vector< int > *)jarg2;
47661   if (!arg2) {
47662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47663     return 0;
47664   }
47665   {
47666     try {
47667       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
47668     } catch (std::out_of_range& e) {
47669       {
47670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47671       };
47672     } catch (std::exception& e) {
47673       {
47674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47675       };
47676     } catch (Dali::DaliException e) {
47677       {
47678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47679       };
47680     } catch (...) {
47681       {
47682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47683       };
47684     }
47685   }
47686
47687   jresult = (void *)result;
47688   return jresult;
47689 }
47690
47691
47692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
47693   void * jresult ;
47694   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47695   Dali::Vector< int >::Iterator result;
47696
47697   arg1 = (Dali::Vector< int > *)jarg1;
47698   {
47699     try {
47700       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
47701     } catch (std::out_of_range& e) {
47702       {
47703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47704       };
47705     } catch (std::exception& e) {
47706       {
47707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47708       };
47709     } catch (Dali::DaliException e) {
47710       {
47711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47712       };
47713     } catch (...) {
47714       {
47715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47716       };
47717     }
47718   }
47719
47720   jresult = (void *)result;
47721   return jresult;
47722 }
47723
47724
47725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
47726   void * jresult ;
47727   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47728   Dali::Vector< int >::Iterator result;
47729
47730   arg1 = (Dali::Vector< int > *)jarg1;
47731   {
47732     try {
47733       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
47734     } catch (std::out_of_range& e) {
47735       {
47736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47737       };
47738     } catch (std::exception& e) {
47739       {
47740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47741       };
47742     } catch (Dali::DaliException e) {
47743       {
47744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47745       };
47746     } catch (...) {
47747       {
47748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47749       };
47750     }
47751   }
47752
47753   jresult = (void *)result;
47754   return jresult;
47755 }
47756
47757
47758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47759   void * jresult ;
47760   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47761   Dali::Vector< int >::SizeType arg2 ;
47762   Dali::Vector< int >::ItemType *result = 0 ;
47763
47764   arg1 = (Dali::Vector< int > *)jarg1;
47765   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47766   {
47767     try {
47768       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
47769     } catch (std::out_of_range& e) {
47770       {
47771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47772       };
47773     } catch (std::exception& e) {
47774       {
47775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47776       };
47777     } catch (Dali::DaliException e) {
47778       {
47779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47780       };
47781     } catch (...) {
47782       {
47783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47784       };
47785     }
47786   }
47787
47788   jresult = (void *)result;
47789   return jresult;
47790 }
47791
47792
47793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
47794   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47795   Dali::Vector< int >::ItemType *arg2 = 0 ;
47796   Dali::Vector< int >::ItemType temp2 ;
47797
47798   arg1 = (Dali::Vector< int > *)jarg1;
47799   temp2 = (Dali::Vector< int >::ItemType)jarg2;
47800   arg2 = &temp2;
47801   {
47802     try {
47803       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
47804     } catch (std::out_of_range& e) {
47805       {
47806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47807       };
47808     } catch (std::exception& e) {
47809       {
47810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47811       };
47812     } catch (Dali::DaliException e) {
47813       {
47814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47815       };
47816     } catch (...) {
47817       {
47818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47819       };
47820     }
47821   }
47822
47823 }
47824
47825
47826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
47827   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47828   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47829   Dali::Vector< int >::ItemType *arg3 = 0 ;
47830   Dali::Vector< int >::ItemType temp3 ;
47831
47832   arg1 = (Dali::Vector< int > *)jarg1;
47833   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47834   temp3 = (Dali::Vector< int >::ItemType)jarg3;
47835   arg3 = &temp3;
47836   {
47837     try {
47838       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
47839     } catch (std::out_of_range& e) {
47840       {
47841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47842       };
47843     } catch (std::exception& e) {
47844       {
47845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47846       };
47847     } catch (Dali::DaliException e) {
47848       {
47849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47850       };
47851     } catch (...) {
47852       {
47853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47854       };
47855     }
47856   }
47857
47858 }
47859
47860
47861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47862   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47863   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47864   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
47865   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
47866
47867   arg1 = (Dali::Vector< int > *)jarg1;
47868   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47869   arg3 = (Dali::Vector< int >::Iterator)jarg3;
47870   arg4 = (Dali::Vector< int >::Iterator)jarg4;
47871   {
47872     try {
47873       (arg1)->Insert(arg2,arg3,arg4);
47874     } catch (std::out_of_range& e) {
47875       {
47876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47877       };
47878     } catch (std::exception& e) {
47879       {
47880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47881       };
47882     } catch (Dali::DaliException e) {
47883       {
47884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47885       };
47886     } catch (...) {
47887       {
47888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47889       };
47890     }
47891   }
47892
47893 }
47894
47895
47896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
47897   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47898   Dali::Vector< int >::SizeType arg2 ;
47899
47900   arg1 = (Dali::Vector< int > *)jarg1;
47901   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47902   {
47903     try {
47904       (arg1)->Reserve(arg2);
47905     } catch (std::out_of_range& e) {
47906       {
47907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47908       };
47909     } catch (std::exception& e) {
47910       {
47911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47912       };
47913     } catch (Dali::DaliException e) {
47914       {
47915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47916       };
47917     } catch (...) {
47918       {
47919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47920       };
47921     }
47922   }
47923
47924 }
47925
47926
47927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47928   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47929   Dali::Vector< int >::SizeType arg2 ;
47930
47931   arg1 = (Dali::Vector< int > *)jarg1;
47932   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47933   {
47934     try {
47935       (arg1)->Resize(arg2);
47936     } catch (std::out_of_range& e) {
47937       {
47938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47939       };
47940     } catch (std::exception& e) {
47941       {
47942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47943       };
47944     } catch (Dali::DaliException e) {
47945       {
47946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47947       };
47948     } catch (...) {
47949       {
47950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47951       };
47952     }
47953   }
47954
47955 }
47956
47957
47958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
47959   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47960   Dali::Vector< int >::SizeType arg2 ;
47961   Dali::Vector< int >::ItemType *arg3 = 0 ;
47962   Dali::Vector< int >::ItemType temp3 ;
47963
47964   arg1 = (Dali::Vector< int > *)jarg1;
47965   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47966   temp3 = (Dali::Vector< int >::ItemType)jarg3;
47967   arg3 = &temp3;
47968   {
47969     try {
47970       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
47971     } catch (std::out_of_range& e) {
47972       {
47973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47974       };
47975     } catch (std::exception& e) {
47976       {
47977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47978       };
47979     } catch (Dali::DaliException e) {
47980       {
47981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47982       };
47983     } catch (...) {
47984       {
47985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47986       };
47987     }
47988   }
47989
47990 }
47991
47992
47993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
47994   void * jresult ;
47995   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47996   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47997   Dali::Vector< int >::Iterator result;
47998
47999   arg1 = (Dali::Vector< int > *)jarg1;
48000   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48001   {
48002     try {
48003       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
48004     } catch (std::out_of_range& e) {
48005       {
48006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48007       };
48008     } catch (std::exception& e) {
48009       {
48010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48011       };
48012     } catch (Dali::DaliException e) {
48013       {
48014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48015       };
48016     } catch (...) {
48017       {
48018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48019       };
48020     }
48021   }
48022
48023   jresult = (void *)result;
48024   return jresult;
48025 }
48026
48027
48028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48029   void * jresult ;
48030   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48031   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48032   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48033   Dali::Vector< int >::Iterator result;
48034
48035   arg1 = (Dali::Vector< int > *)jarg1;
48036   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48037   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48038   {
48039     try {
48040       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
48041     } catch (std::out_of_range& e) {
48042       {
48043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48044       };
48045     } catch (std::exception& e) {
48046       {
48047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48048       };
48049     } catch (Dali::DaliException e) {
48050       {
48051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48052       };
48053     } catch (...) {
48054       {
48055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48056       };
48057     }
48058   }
48059
48060   jresult = (void *)result;
48061   return jresult;
48062 }
48063
48064
48065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
48066   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48067   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48068
48069   arg1 = (Dali::Vector< int > *)jarg1;
48070   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48071   {
48072     try {
48073       (arg1)->Remove(arg2);
48074     } catch (std::out_of_range& e) {
48075       {
48076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48077       };
48078     } catch (std::exception& e) {
48079       {
48080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48081       };
48082     } catch (Dali::DaliException e) {
48083       {
48084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48085       };
48086     } catch (...) {
48087       {
48088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48089       };
48090     }
48091   }
48092
48093 }
48094
48095
48096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
48097   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48098   Dali::Vector< int > *arg2 = 0 ;
48099
48100   arg1 = (Dali::Vector< int > *)jarg1;
48101   arg2 = (Dali::Vector< int > *)jarg2;
48102   if (!arg2) {
48103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
48104     return ;
48105   }
48106   {
48107     try {
48108       (arg1)->Swap(*arg2);
48109     } catch (std::out_of_range& e) {
48110       {
48111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48112       };
48113     } catch (std::exception& e) {
48114       {
48115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48116       };
48117     } catch (Dali::DaliException e) {
48118       {
48119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48120       };
48121     } catch (...) {
48122       {
48123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48124       };
48125     }
48126   }
48127
48128 }
48129
48130
48131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
48132   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48133
48134   arg1 = (Dali::Vector< int > *)jarg1;
48135   {
48136     try {
48137       (arg1)->Clear();
48138     } catch (std::out_of_range& e) {
48139       {
48140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48141       };
48142     } catch (std::exception& e) {
48143       {
48144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48145       };
48146     } catch (Dali::DaliException e) {
48147       {
48148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48149       };
48150     } catch (...) {
48151       {
48152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48153       };
48154     }
48155   }
48156
48157 }
48158
48159
48160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
48161   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48162
48163   arg1 = (Dali::Vector< int > *)jarg1;
48164   {
48165     try {
48166       (arg1)->Release();
48167     } catch (std::out_of_range& e) {
48168       {
48169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48170       };
48171     } catch (std::exception& e) {
48172       {
48173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48174       };
48175     } catch (Dali::DaliException e) {
48176       {
48177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48178       };
48179     } catch (...) {
48180       {
48181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48182       };
48183     }
48184   }
48185
48186 }
48187
48188
48189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
48190   int jresult ;
48191   int result;
48192
48193   result = (int)Dali::Vector< float >::BaseType;
48194   jresult = (int)result;
48195   return jresult;
48196 }
48197
48198
48199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
48200   void * jresult ;
48201   Dali::Vector< float > *result = 0 ;
48202
48203   {
48204     try {
48205       result = (Dali::Vector< float > *)new Dali::Vector< float >();
48206     } catch (std::out_of_range& e) {
48207       {
48208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48209       };
48210     } catch (std::exception& e) {
48211       {
48212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48213       };
48214     } catch (Dali::DaliException e) {
48215       {
48216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48217       };
48218     } catch (...) {
48219       {
48220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48221       };
48222     }
48223   }
48224
48225   jresult = (void *)result;
48226   return jresult;
48227 }
48228
48229
48230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
48231   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48232
48233   arg1 = (Dali::Vector< float > *)jarg1;
48234   {
48235     try {
48236       delete arg1;
48237     } catch (std::out_of_range& e) {
48238       {
48239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48240       };
48241     } catch (std::exception& e) {
48242       {
48243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48244       };
48245     } catch (Dali::DaliException e) {
48246       {
48247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48248       };
48249     } catch (...) {
48250       {
48251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48252       };
48253     }
48254   }
48255
48256 }
48257
48258
48259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
48260   void * jresult ;
48261   Dali::Vector< float > *arg1 = 0 ;
48262   Dali::Vector< float > *result = 0 ;
48263
48264   arg1 = (Dali::Vector< float > *)jarg1;
48265   if (!arg1) {
48266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48267     return 0;
48268   }
48269   {
48270     try {
48271       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
48272     } catch (std::out_of_range& e) {
48273       {
48274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48275       };
48276     } catch (std::exception& e) {
48277       {
48278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48279       };
48280     } catch (Dali::DaliException e) {
48281       {
48282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48283       };
48284     } catch (...) {
48285       {
48286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48287       };
48288     }
48289   }
48290
48291   jresult = (void *)result;
48292   return jresult;
48293 }
48294
48295
48296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
48297   void * jresult ;
48298   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48299   Dali::Vector< float > *arg2 = 0 ;
48300   Dali::Vector< float > *result = 0 ;
48301
48302   arg1 = (Dali::Vector< float > *)jarg1;
48303   arg2 = (Dali::Vector< float > *)jarg2;
48304   if (!arg2) {
48305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48306     return 0;
48307   }
48308   {
48309     try {
48310       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
48311     } catch (std::out_of_range& e) {
48312       {
48313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48314       };
48315     } catch (std::exception& e) {
48316       {
48317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48318       };
48319     } catch (Dali::DaliException e) {
48320       {
48321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48322       };
48323     } catch (...) {
48324       {
48325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48326       };
48327     }
48328   }
48329
48330   jresult = (void *)result;
48331   return jresult;
48332 }
48333
48334
48335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
48336   void * jresult ;
48337   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48338   Dali::Vector< float >::Iterator result;
48339
48340   arg1 = (Dali::Vector< float > *)jarg1;
48341   {
48342     try {
48343       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
48344     } catch (std::out_of_range& e) {
48345       {
48346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48347       };
48348     } catch (std::exception& e) {
48349       {
48350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48351       };
48352     } catch (Dali::DaliException e) {
48353       {
48354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48355       };
48356     } catch (...) {
48357       {
48358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48359       };
48360     }
48361   }
48362
48363   jresult = (void *)result;
48364   return jresult;
48365 }
48366
48367
48368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
48369   void * jresult ;
48370   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48371   Dali::Vector< float >::Iterator result;
48372
48373   arg1 = (Dali::Vector< float > *)jarg1;
48374   {
48375     try {
48376       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
48377     } catch (std::out_of_range& e) {
48378       {
48379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48380       };
48381     } catch (std::exception& e) {
48382       {
48383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48384       };
48385     } catch (Dali::DaliException e) {
48386       {
48387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48388       };
48389     } catch (...) {
48390       {
48391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48392       };
48393     }
48394   }
48395
48396   jresult = (void *)result;
48397   return jresult;
48398 }
48399
48400
48401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48402   void * jresult ;
48403   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48404   Dali::Vector< float >::SizeType arg2 ;
48405   Dali::Vector< float >::ItemType *result = 0 ;
48406
48407   arg1 = (Dali::Vector< float > *)jarg1;
48408   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48409   {
48410     try {
48411       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
48412     } catch (std::out_of_range& e) {
48413       {
48414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48415       };
48416     } catch (std::exception& e) {
48417       {
48418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48419       };
48420     } catch (Dali::DaliException e) {
48421       {
48422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48423       };
48424     } catch (...) {
48425       {
48426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48427       };
48428     }
48429   }
48430
48431   jresult = (void *)result;
48432   return jresult;
48433 }
48434
48435
48436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
48437   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48438   Dali::Vector< float >::ItemType *arg2 = 0 ;
48439   Dali::Vector< float >::ItemType temp2 ;
48440
48441   arg1 = (Dali::Vector< float > *)jarg1;
48442   temp2 = (Dali::Vector< float >::ItemType)jarg2;
48443   arg2 = &temp2;
48444   {
48445     try {
48446       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
48447     } catch (std::out_of_range& e) {
48448       {
48449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48450       };
48451     } catch (std::exception& e) {
48452       {
48453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48454       };
48455     } catch (Dali::DaliException e) {
48456       {
48457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48458       };
48459     } catch (...) {
48460       {
48461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48462       };
48463     }
48464   }
48465
48466 }
48467
48468
48469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
48470   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48471   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48472   Dali::Vector< float >::ItemType *arg3 = 0 ;
48473   Dali::Vector< float >::ItemType temp3 ;
48474
48475   arg1 = (Dali::Vector< float > *)jarg1;
48476   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48477   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48478   arg3 = &temp3;
48479   {
48480     try {
48481       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48482     } catch (std::out_of_range& e) {
48483       {
48484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48485       };
48486     } catch (std::exception& e) {
48487       {
48488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48489       };
48490     } catch (Dali::DaliException e) {
48491       {
48492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48493       };
48494     } catch (...) {
48495       {
48496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48497       };
48498     }
48499   }
48500
48501 }
48502
48503
48504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48505   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48506   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48507   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48508   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
48509
48510   arg1 = (Dali::Vector< float > *)jarg1;
48511   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48512   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48513   arg4 = (Dali::Vector< float >::Iterator)jarg4;
48514   {
48515     try {
48516       (arg1)->Insert(arg2,arg3,arg4);
48517     } catch (std::out_of_range& e) {
48518       {
48519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48520       };
48521     } catch (std::exception& e) {
48522       {
48523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48524       };
48525     } catch (Dali::DaliException e) {
48526       {
48527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48528       };
48529     } catch (...) {
48530       {
48531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48532       };
48533     }
48534   }
48535
48536 }
48537
48538
48539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
48540   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48541   Dali::Vector< float >::SizeType arg2 ;
48542
48543   arg1 = (Dali::Vector< float > *)jarg1;
48544   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48545   {
48546     try {
48547       (arg1)->Reserve(arg2);
48548     } catch (std::out_of_range& e) {
48549       {
48550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48551       };
48552     } catch (std::exception& e) {
48553       {
48554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48555       };
48556     } catch (Dali::DaliException e) {
48557       {
48558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48559       };
48560     } catch (...) {
48561       {
48562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48563       };
48564     }
48565   }
48566
48567 }
48568
48569 //// ========================= end of part 2 =============================
48570
48571 //// ========================== start part 3 ===============================
48572
48573
48574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48575   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48576   Dali::Vector< float >::SizeType arg2 ;
48577
48578   arg1 = (Dali::Vector< float > *)jarg1;
48579   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48580   {
48581     try {
48582       (arg1)->Resize(arg2);
48583     } catch (std::out_of_range& e) {
48584       {
48585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48586       };
48587     } catch (std::exception& e) {
48588       {
48589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48590       };
48591     } catch (Dali::DaliException e) {
48592       {
48593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48594       };
48595     } catch (...) {
48596       {
48597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48598       };
48599     }
48600   }
48601
48602 }
48603
48604
48605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
48606   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48607   Dali::Vector< float >::SizeType arg2 ;
48608   Dali::Vector< float >::ItemType *arg3 = 0 ;
48609   Dali::Vector< float >::ItemType temp3 ;
48610
48611   arg1 = (Dali::Vector< float > *)jarg1;
48612   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48613   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48614   arg3 = &temp3;
48615   {
48616     try {
48617       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48618     } catch (std::out_of_range& e) {
48619       {
48620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48621       };
48622     } catch (std::exception& e) {
48623       {
48624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48625       };
48626     } catch (Dali::DaliException e) {
48627       {
48628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48629       };
48630     } catch (...) {
48631       {
48632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48633       };
48634     }
48635   }
48636
48637 }
48638
48639
48640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
48641   void * jresult ;
48642   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48643   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48644   Dali::Vector< float >::Iterator result;
48645
48646   arg1 = (Dali::Vector< float > *)jarg1;
48647   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48648   {
48649     try {
48650       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
48651     } catch (std::out_of_range& e) {
48652       {
48653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48654       };
48655     } catch (std::exception& e) {
48656       {
48657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48658       };
48659     } catch (Dali::DaliException e) {
48660       {
48661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48662       };
48663     } catch (...) {
48664       {
48665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48666       };
48667     }
48668   }
48669
48670   jresult = (void *)result;
48671   return jresult;
48672 }
48673
48674
48675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48676   void * jresult ;
48677   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48678   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48679   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48680   Dali::Vector< float >::Iterator result;
48681
48682   arg1 = (Dali::Vector< float > *)jarg1;
48683   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48684   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48685   {
48686     try {
48687       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
48688     } catch (std::out_of_range& e) {
48689       {
48690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48691       };
48692     } catch (std::exception& e) {
48693       {
48694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48695       };
48696     } catch (Dali::DaliException e) {
48697       {
48698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48699       };
48700     } catch (...) {
48701       {
48702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48703       };
48704     }
48705   }
48706
48707   jresult = (void *)result;
48708   return jresult;
48709 }
48710
48711
48712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
48713   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48714   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48715
48716   arg1 = (Dali::Vector< float > *)jarg1;
48717   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48718   {
48719     try {
48720       (arg1)->Remove(arg2);
48721     } catch (std::out_of_range& e) {
48722       {
48723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48724       };
48725     } catch (std::exception& e) {
48726       {
48727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48728       };
48729     } catch (Dali::DaliException e) {
48730       {
48731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48732       };
48733     } catch (...) {
48734       {
48735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48736       };
48737     }
48738   }
48739
48740 }
48741
48742
48743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
48744   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48745   Dali::Vector< float > *arg2 = 0 ;
48746
48747   arg1 = (Dali::Vector< float > *)jarg1;
48748   arg2 = (Dali::Vector< float > *)jarg2;
48749   if (!arg2) {
48750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
48751     return ;
48752   }
48753   {
48754     try {
48755       (arg1)->Swap(*arg2);
48756     } catch (std::out_of_range& e) {
48757       {
48758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48759       };
48760     } catch (std::exception& e) {
48761       {
48762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48763       };
48764     } catch (Dali::DaliException e) {
48765       {
48766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48767       };
48768     } catch (...) {
48769       {
48770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48771       };
48772     }
48773   }
48774
48775 }
48776
48777
48778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
48779   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48780
48781   arg1 = (Dali::Vector< float > *)jarg1;
48782   {
48783     try {
48784       (arg1)->Clear();
48785     } catch (std::out_of_range& e) {
48786       {
48787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48788       };
48789     } catch (std::exception& e) {
48790       {
48791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48792       };
48793     } catch (Dali::DaliException e) {
48794       {
48795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48796       };
48797     } catch (...) {
48798       {
48799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48800       };
48801     }
48802   }
48803
48804 }
48805
48806
48807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
48808   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48809
48810   arg1 = (Dali::Vector< float > *)jarg1;
48811   {
48812     try {
48813       (arg1)->Release();
48814     } catch (std::out_of_range& e) {
48815       {
48816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48817       };
48818     } catch (std::exception& e) {
48819       {
48820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48821       };
48822     } catch (Dali::DaliException e) {
48823       {
48824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48825       };
48826     } catch (...) {
48827       {
48828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48829       };
48830     }
48831   }
48832
48833 }
48834
48835
48836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
48837   int jresult ;
48838   int result;
48839
48840   result = (int)Dali::Vector< unsigned char >::BaseType;
48841   jresult = (int)result;
48842   return jresult;
48843 }
48844
48845
48846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
48847   void * jresult ;
48848   Dali::Vector< unsigned char > *result = 0 ;
48849
48850   {
48851     try {
48852       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
48853     } catch (std::out_of_range& e) {
48854       {
48855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48856       };
48857     } catch (std::exception& e) {
48858       {
48859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48860       };
48861     } catch (Dali::DaliException e) {
48862       {
48863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48864       };
48865     } catch (...) {
48866       {
48867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48868       };
48869     }
48870   }
48871
48872   jresult = (void *)result;
48873   return jresult;
48874 }
48875
48876
48877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
48878   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48879
48880   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48881   {
48882     try {
48883       delete arg1;
48884     } catch (std::out_of_range& e) {
48885       {
48886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48887       };
48888     } catch (std::exception& e) {
48889       {
48890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48891       };
48892     } catch (Dali::DaliException e) {
48893       {
48894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48895       };
48896     } catch (...) {
48897       {
48898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48899       };
48900     }
48901   }
48902
48903 }
48904
48905
48906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
48907   void * jresult ;
48908   Dali::Vector< unsigned char > *arg1 = 0 ;
48909   Dali::Vector< unsigned char > *result = 0 ;
48910
48911   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48912   if (!arg1) {
48913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
48914     return 0;
48915   }
48916   {
48917     try {
48918       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
48919     } catch (std::out_of_range& e) {
48920       {
48921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48922       };
48923     } catch (std::exception& e) {
48924       {
48925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48926       };
48927     } catch (Dali::DaliException e) {
48928       {
48929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48930       };
48931     } catch (...) {
48932       {
48933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48934       };
48935     }
48936   }
48937
48938   jresult = (void *)result;
48939   return jresult;
48940 }
48941
48942
48943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
48944   void * jresult ;
48945   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48946   Dali::Vector< unsigned char > *arg2 = 0 ;
48947   Dali::Vector< unsigned char > *result = 0 ;
48948
48949   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48950   arg2 = (Dali::Vector< unsigned char > *)jarg2;
48951   if (!arg2) {
48952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
48953     return 0;
48954   }
48955   {
48956     try {
48957       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
48958     } catch (std::out_of_range& e) {
48959       {
48960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48961       };
48962     } catch (std::exception& e) {
48963       {
48964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48965       };
48966     } catch (Dali::DaliException e) {
48967       {
48968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48969       };
48970     } catch (...) {
48971       {
48972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48973       };
48974     }
48975   }
48976
48977   jresult = (void *)result;
48978   return jresult;
48979 }
48980
48981
48982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
48983   void * jresult ;
48984   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48985   Dali::Vector< unsigned char >::Iterator result;
48986
48987   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48988   {
48989     try {
48990       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
48991     } catch (std::out_of_range& e) {
48992       {
48993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48994       };
48995     } catch (std::exception& e) {
48996       {
48997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48998       };
48999     } catch (Dali::DaliException e) {
49000       {
49001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49002       };
49003     } catch (...) {
49004       {
49005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49006       };
49007     }
49008   }
49009
49010   jresult = (void *)result;
49011   return jresult;
49012 }
49013
49014
49015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
49016   void * jresult ;
49017   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49018   Dali::Vector< unsigned char >::Iterator result;
49019
49020   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49021   {
49022     try {
49023       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
49024     } catch (std::out_of_range& e) {
49025       {
49026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49027       };
49028     } catch (std::exception& e) {
49029       {
49030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49031       };
49032     } catch (Dali::DaliException e) {
49033       {
49034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49035       };
49036     } catch (...) {
49037       {
49038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49039       };
49040     }
49041   }
49042
49043   jresult = (void *)result;
49044   return jresult;
49045 }
49046
49047
49048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49049   void * jresult ;
49050   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49051   Dali::Vector< unsigned char >::SizeType arg2 ;
49052   Dali::Vector< unsigned char >::ItemType *result = 0 ;
49053
49054   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49055   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49056   {
49057     try {
49058       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
49059     } catch (std::out_of_range& e) {
49060       {
49061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49062       };
49063     } catch (std::exception& e) {
49064       {
49065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49066       };
49067     } catch (Dali::DaliException e) {
49068       {
49069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49070       };
49071     } catch (...) {
49072       {
49073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49074       };
49075     }
49076   }
49077
49078   jresult = (void *)result;
49079   return jresult;
49080 }
49081
49082
49083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
49084   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49085   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
49086   Dali::Vector< unsigned char >::ItemType temp2 ;
49087
49088   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49089   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
49090   arg2 = &temp2;
49091   {
49092     try {
49093       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
49094     } catch (std::out_of_range& e) {
49095       {
49096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49097       };
49098     } catch (std::exception& e) {
49099       {
49100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49101       };
49102     } catch (Dali::DaliException e) {
49103       {
49104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49105       };
49106     } catch (...) {
49107       {
49108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49109       };
49110     }
49111   }
49112
49113 }
49114
49115
49116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
49117   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49118   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49119   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49120   Dali::Vector< unsigned char >::ItemType temp3 ;
49121
49122   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49123   arg2 = jarg2;
49124   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49125   arg3 = &temp3;
49126   {
49127     try {
49128       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49129     } catch (std::out_of_range& e) {
49130       {
49131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49132       };
49133     } catch (std::exception& e) {
49134       {
49135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49136       };
49137     } catch (Dali::DaliException e) {
49138       {
49139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49140       };
49141     } catch (...) {
49142       {
49143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49144       };
49145     }
49146   }
49147
49148
49149
49150 }
49151
49152
49153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
49154   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49155   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49156   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49157   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49158
49159   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49160   arg2 = jarg2;
49161   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49162   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
49163   {
49164     try {
49165       (arg1)->Insert(arg2,arg3,arg4);
49166     } catch (std::out_of_range& e) {
49167       {
49168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49169       };
49170     } catch (std::exception& e) {
49171       {
49172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49173       };
49174     } catch (Dali::DaliException e) {
49175       {
49176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49177       };
49178     } catch (...) {
49179       {
49180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49181       };
49182     }
49183   }
49184
49185
49186
49187 }
49188
49189
49190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
49191   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49192   Dali::Vector< unsigned char >::SizeType arg2 ;
49193
49194   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49195   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49196   {
49197     try {
49198       (arg1)->Reserve(arg2);
49199     } catch (std::out_of_range& e) {
49200       {
49201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49202       };
49203     } catch (std::exception& e) {
49204       {
49205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49206       };
49207     } catch (Dali::DaliException e) {
49208       {
49209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49210       };
49211     } catch (...) {
49212       {
49213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49214       };
49215     }
49216   }
49217
49218 }
49219
49220
49221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49222   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49223   Dali::Vector< unsigned char >::SizeType arg2 ;
49224
49225   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49226   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49227   {
49228     try {
49229       (arg1)->Resize(arg2);
49230     } catch (std::out_of_range& e) {
49231       {
49232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49233       };
49234     } catch (std::exception& e) {
49235       {
49236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49237       };
49238     } catch (Dali::DaliException e) {
49239       {
49240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49241       };
49242     } catch (...) {
49243       {
49244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49245       };
49246     }
49247   }
49248
49249 }
49250
49251
49252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
49253   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49254   Dali::Vector< unsigned char >::SizeType arg2 ;
49255   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49256   Dali::Vector< unsigned char >::ItemType temp3 ;
49257
49258   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49259   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49260   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49261   arg3 = &temp3;
49262   {
49263     try {
49264       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49265     } catch (std::out_of_range& e) {
49266       {
49267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49268       };
49269     } catch (std::exception& e) {
49270       {
49271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49272       };
49273     } catch (Dali::DaliException e) {
49274       {
49275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49276       };
49277     } catch (...) {
49278       {
49279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49280       };
49281     }
49282   }
49283
49284 }
49285
49286
49287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
49288   void * jresult ;
49289   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49290   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49291   Dali::Vector< unsigned char >::Iterator result;
49292
49293   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49294   arg2 = jarg2;
49295   {
49296     try {
49297       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
49298     } catch (std::out_of_range& e) {
49299       {
49300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49301       };
49302     } catch (std::exception& e) {
49303       {
49304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49305       };
49306     } catch (Dali::DaliException e) {
49307       {
49308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49309       };
49310     } catch (...) {
49311       {
49312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49313       };
49314     }
49315   }
49316
49317   jresult = (void *)result;
49318
49319
49320   return jresult;
49321 }
49322
49323
49324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
49325   void * jresult ;
49326   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49327   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49328   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49329   Dali::Vector< unsigned char >::Iterator result;
49330
49331   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49332   arg2 = jarg2;
49333   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49334   {
49335     try {
49336       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
49337     } catch (std::out_of_range& e) {
49338       {
49339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49340       };
49341     } catch (std::exception& e) {
49342       {
49343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49344       };
49345     } catch (Dali::DaliException e) {
49346       {
49347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49348       };
49349     } catch (...) {
49350       {
49351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49352       };
49353     }
49354   }
49355
49356   jresult = (void *)result;
49357
49358
49359   return jresult;
49360 }
49361
49362
49363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
49364   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49365   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49366
49367   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49368   arg2 = jarg2;
49369   {
49370     try {
49371       (arg1)->Remove(arg2);
49372     } catch (std::out_of_range& e) {
49373       {
49374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49375       };
49376     } catch (std::exception& e) {
49377       {
49378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49379       };
49380     } catch (Dali::DaliException e) {
49381       {
49382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49383       };
49384     } catch (...) {
49385       {
49386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49387       };
49388     }
49389   }
49390
49391
49392
49393 }
49394
49395
49396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
49397   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49398   Dali::Vector< unsigned char > *arg2 = 0 ;
49399
49400   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49401   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49402   if (!arg2) {
49403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
49404     return ;
49405   }
49406   {
49407     try {
49408       (arg1)->Swap(*arg2);
49409     } catch (std::out_of_range& e) {
49410       {
49411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49412       };
49413     } catch (std::exception& e) {
49414       {
49415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49416       };
49417     } catch (Dali::DaliException e) {
49418       {
49419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49420       };
49421     } catch (...) {
49422       {
49423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49424       };
49425     }
49426   }
49427
49428 }
49429
49430
49431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
49432   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49433
49434   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49435   {
49436     try {
49437       (arg1)->Clear();
49438     } catch (std::out_of_range& e) {
49439       {
49440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49441       };
49442     } catch (std::exception& e) {
49443       {
49444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49445       };
49446     } catch (Dali::DaliException e) {
49447       {
49448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49449       };
49450     } catch (...) {
49451       {
49452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49453       };
49454     }
49455   }
49456
49457 }
49458
49459
49460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
49461   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49462
49463   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49464   {
49465     try {
49466       (arg1)->Release();
49467     } catch (std::out_of_range& e) {
49468       {
49469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49470       };
49471     } catch (std::exception& e) {
49472       {
49473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49474       };
49475     } catch (Dali::DaliException e) {
49476       {
49477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49478       };
49479     } catch (...) {
49480       {
49481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49482       };
49483     }
49484   }
49485
49486 }
49487
49488
49489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
49490   int jresult ;
49491   int result;
49492
49493   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
49494   jresult = (int)result;
49495   return jresult;
49496 }
49497
49498
49499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
49500   void * jresult ;
49501   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49502
49503   {
49504     try {
49505       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
49506     } catch (std::out_of_range& e) {
49507       {
49508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49509       };
49510     } catch (std::exception& e) {
49511       {
49512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49513       };
49514     } catch (Dali::DaliException e) {
49515       {
49516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49517       };
49518     } catch (...) {
49519       {
49520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49521       };
49522     }
49523   }
49524
49525   jresult = (void *)result;
49526   return jresult;
49527 }
49528
49529
49530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
49531   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49532
49533   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49534   {
49535     try {
49536       delete arg1;
49537     } catch (std::out_of_range& e) {
49538       {
49539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49540       };
49541     } catch (std::exception& e) {
49542       {
49543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49544       };
49545     } catch (Dali::DaliException e) {
49546       {
49547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49548       };
49549     } catch (...) {
49550       {
49551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49552       };
49553     }
49554   }
49555
49556 }
49557
49558
49559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
49560   void * jresult ;
49561   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
49562   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49563
49564   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49565   if (!arg1) {
49566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49567     return 0;
49568   }
49569   {
49570     try {
49571       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
49572     } catch (std::out_of_range& e) {
49573       {
49574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49575       };
49576     } catch (std::exception& e) {
49577       {
49578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49579       };
49580     } catch (Dali::DaliException e) {
49581       {
49582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49583       };
49584     } catch (...) {
49585       {
49586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49587       };
49588     }
49589   }
49590
49591   jresult = (void *)result;
49592   return jresult;
49593 }
49594
49595
49596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
49597   void * jresult ;
49598   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49599   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
49600   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49601
49602   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49603   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
49604   if (!arg2) {
49605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49606     return 0;
49607   }
49608   {
49609     try {
49610       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
49611     } catch (std::out_of_range& e) {
49612       {
49613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49614       };
49615     } catch (std::exception& e) {
49616       {
49617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49618       };
49619     } catch (Dali::DaliException e) {
49620       {
49621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49622       };
49623     } catch (...) {
49624       {
49625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49626       };
49627     }
49628   }
49629
49630   jresult = (void *)result;
49631   return jresult;
49632 }
49633
49634
49635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
49636   void * jresult ;
49637   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49638   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49639
49640   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49641   {
49642     try {
49643       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
49644     } catch (std::out_of_range& e) {
49645       {
49646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49647       };
49648     } catch (std::exception& e) {
49649       {
49650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49651       };
49652     } catch (Dali::DaliException e) {
49653       {
49654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49655       };
49656     } catch (...) {
49657       {
49658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49659       };
49660     }
49661   }
49662
49663   jresult = (void *)result;
49664   return jresult;
49665 }
49666
49667
49668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
49669   void * jresult ;
49670   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49671   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49672
49673   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49674   {
49675     try {
49676       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
49677     } catch (std::out_of_range& e) {
49678       {
49679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49680       };
49681     } catch (std::exception& e) {
49682       {
49683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49684       };
49685     } catch (Dali::DaliException e) {
49686       {
49687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49688       };
49689     } catch (...) {
49690       {
49691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49692       };
49693     }
49694   }
49695
49696   jresult = (void *)result;
49697   return jresult;
49698 }
49699
49700
49701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49702   void * jresult ;
49703   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49704   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49705   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
49706
49707   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49708   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49709   {
49710     try {
49711       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
49712     } catch (std::out_of_range& e) {
49713       {
49714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49715       };
49716     } catch (std::exception& e) {
49717       {
49718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49719       };
49720     } catch (Dali::DaliException e) {
49721       {
49722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49723       };
49724     } catch (...) {
49725       {
49726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49727       };
49728     }
49729   }
49730
49731   jresult = (void *)result;
49732   return jresult;
49733 }
49734
49735
49736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
49737   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49738   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
49739
49740   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49741   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
49742   if (!arg2) {
49743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49744     return ;
49745   }
49746   {
49747     try {
49748       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
49749     } catch (std::out_of_range& e) {
49750       {
49751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49752       };
49753     } catch (std::exception& e) {
49754       {
49755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49756       };
49757     } catch (Dali::DaliException e) {
49758       {
49759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49760       };
49761     } catch (...) {
49762       {
49763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49764       };
49765     }
49766   }
49767
49768 }
49769
49770
49771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
49772   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49773   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49774   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
49775
49776   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49777   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49778   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
49779   if (!arg3) {
49780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49781     return ;
49782   }
49783   {
49784     try {
49785       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
49786     } catch (std::out_of_range& e) {
49787       {
49788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49789       };
49790     } catch (std::exception& e) {
49791       {
49792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49793       };
49794     } catch (Dali::DaliException e) {
49795       {
49796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49797       };
49798     } catch (...) {
49799       {
49800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49801       };
49802     }
49803   }
49804
49805 }
49806
49807
49808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
49809   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49810   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49811   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49812   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49813
49814   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49815   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49816   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
49817   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
49818   {
49819     try {
49820       (arg1)->Insert(arg2,arg3,arg4);
49821     } catch (std::out_of_range& e) {
49822       {
49823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49824       };
49825     } catch (std::exception& e) {
49826       {
49827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49828       };
49829     } catch (Dali::DaliException e) {
49830       {
49831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49832       };
49833     } catch (...) {
49834       {
49835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49836       };
49837     }
49838   }
49839
49840 }
49841
49842
49843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
49844   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49845   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49846
49847   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49848   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49849   {
49850     try {
49851       (arg1)->Reserve(arg2);
49852     } catch (std::out_of_range& e) {
49853       {
49854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49855       };
49856     } catch (std::exception& e) {
49857       {
49858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49859       };
49860     } catch (Dali::DaliException e) {
49861       {
49862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49863       };
49864     } catch (...) {
49865       {
49866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49867       };
49868     }
49869   }
49870
49871 }
49872
49873
49874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49875   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49876   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49877
49878   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49879   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49880   {
49881     try {
49882       (arg1)->Resize(arg2);
49883     } catch (std::out_of_range& e) {
49884       {
49885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49886       };
49887     } catch (std::exception& e) {
49888       {
49889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49890       };
49891     } catch (Dali::DaliException e) {
49892       {
49893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49894       };
49895     } catch (...) {
49896       {
49897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49898       };
49899     }
49900   }
49901
49902 }
49903
49904
49905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
49906   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49907   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49908   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
49909
49910   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49911   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49912   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
49913   if (!arg3) {
49914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49915     return ;
49916   }
49917   {
49918     try {
49919       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
49920     } catch (std::out_of_range& e) {
49921       {
49922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49923       };
49924     } catch (std::exception& e) {
49925       {
49926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49927       };
49928     } catch (Dali::DaliException e) {
49929       {
49930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49931       };
49932     } catch (...) {
49933       {
49934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49935       };
49936     }
49937   }
49938
49939 }
49940
49941
49942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
49943   void * jresult ;
49944   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49945   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49946   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49947
49948   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49949   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49950   {
49951     try {
49952       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
49953     } catch (std::out_of_range& e) {
49954       {
49955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49956       };
49957     } catch (std::exception& e) {
49958       {
49959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49960       };
49961     } catch (Dali::DaliException e) {
49962       {
49963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49964       };
49965     } catch (...) {
49966       {
49967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49968       };
49969     }
49970   }
49971
49972   jresult = (void *)result;
49973   return jresult;
49974 }
49975
49976
49977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
49978   void * jresult ;
49979   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49980   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49981   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49982   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49983
49984   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49985   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49986   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
49987   {
49988     try {
49989       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
49990     } catch (std::out_of_range& e) {
49991       {
49992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49993       };
49994     } catch (std::exception& e) {
49995       {
49996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49997       };
49998     } catch (Dali::DaliException e) {
49999       {
50000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50001       };
50002     } catch (...) {
50003       {
50004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50005       };
50006     }
50007   }
50008
50009   jresult = (void *)result;
50010   return jresult;
50011 }
50012
50013
50014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
50015   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50016   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50017
50018   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50019   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50020   {
50021     try {
50022       (arg1)->Remove(arg2);
50023     } catch (std::out_of_range& e) {
50024       {
50025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50026       };
50027     } catch (std::exception& e) {
50028       {
50029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50030       };
50031     } catch (Dali::DaliException e) {
50032       {
50033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50034       };
50035     } catch (...) {
50036       {
50037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50038       };
50039     }
50040   }
50041
50042 }
50043
50044
50045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
50046   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50047   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
50048
50049   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50050   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
50051   if (!arg2) {
50052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
50053     return ;
50054   }
50055   {
50056     try {
50057       (arg1)->Swap(*arg2);
50058     } catch (std::out_of_range& e) {
50059       {
50060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50061       };
50062     } catch (std::exception& e) {
50063       {
50064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50065       };
50066     } catch (Dali::DaliException e) {
50067       {
50068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50069       };
50070     } catch (...) {
50071       {
50072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50073       };
50074     }
50075   }
50076
50077 }
50078
50079
50080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
50081   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50082
50083   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50084   {
50085     try {
50086       (arg1)->Clear();
50087     } catch (std::out_of_range& e) {
50088       {
50089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50090       };
50091     } catch (std::exception& e) {
50092       {
50093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50094       };
50095     } catch (Dali::DaliException e) {
50096       {
50097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50098       };
50099     } catch (...) {
50100       {
50101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50102       };
50103     }
50104   }
50105
50106 }
50107
50108
50109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
50110   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50111
50112   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50113   {
50114     try {
50115       (arg1)->Release();
50116     } catch (std::out_of_range& e) {
50117       {
50118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50119       };
50120     } catch (std::exception& e) {
50121       {
50122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50123       };
50124     } catch (Dali::DaliException e) {
50125       {
50126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50127       };
50128     } catch (...) {
50129       {
50130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50131       };
50132     }
50133   }
50134
50135 }
50136
50137
50138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
50139   void * jresult ;
50140   Dali::Signal< void () > *result = 0 ;
50141
50142   {
50143     try {
50144       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
50145     } catch (std::out_of_range& e) {
50146       {
50147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50148       };
50149     } catch (std::exception& e) {
50150       {
50151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50152       };
50153     } catch (Dali::DaliException e) {
50154       {
50155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50156       };
50157     } catch (...) {
50158       {
50159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50160       };
50161     }
50162   }
50163
50164   jresult = (void *)result;
50165   return jresult;
50166 }
50167
50168
50169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
50170   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50171
50172   arg1 = (Dali::Signal< void () > *)jarg1;
50173   {
50174     try {
50175       delete arg1;
50176     } catch (std::out_of_range& e) {
50177       {
50178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50179       };
50180     } catch (std::exception& e) {
50181       {
50182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50183       };
50184     } catch (Dali::DaliException e) {
50185       {
50186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50187       };
50188     } catch (...) {
50189       {
50190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50191       };
50192     }
50193   }
50194
50195 }
50196
50197
50198 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
50199   unsigned int jresult ;
50200   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50201   bool result;
50202
50203   arg1 = (Dali::Signal< void () > *)jarg1;
50204   {
50205     try {
50206       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
50207     } catch (std::out_of_range& e) {
50208       {
50209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50210       };
50211     } catch (std::exception& e) {
50212       {
50213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50214       };
50215     } catch (Dali::DaliException e) {
50216       {
50217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50218       };
50219     } catch (...) {
50220       {
50221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50222       };
50223     }
50224   }
50225
50226   jresult = result;
50227   return jresult;
50228 }
50229
50230
50231 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
50232   unsigned long jresult ;
50233   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50234   std::size_t result;
50235
50236   arg1 = (Dali::Signal< void () > *)jarg1;
50237   {
50238     try {
50239       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
50240     } catch (std::out_of_range& e) {
50241       {
50242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50243       };
50244     } catch (std::exception& e) {
50245       {
50246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50247       };
50248     } catch (Dali::DaliException e) {
50249       {
50250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50251       };
50252     } catch (...) {
50253       {
50254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50255       };
50256     }
50257   }
50258
50259   jresult = (unsigned long)result;
50260   return jresult;
50261 }
50262
50263
50264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
50265   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50266   void (*arg2)() = (void (*)()) 0 ;
50267
50268   arg1 = (Dali::Signal< void () > *)jarg1;
50269   arg2 = (void (*)())jarg2;
50270   {
50271     try {
50272       (arg1)->Connect(arg2);
50273     } catch (std::out_of_range& e) {
50274       {
50275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50276       };
50277     } catch (std::exception& e) {
50278       {
50279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50280       };
50281     } catch (Dali::DaliException e) {
50282       {
50283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50284       };
50285     } catch (...) {
50286       {
50287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50288       };
50289     }
50290   }
50291
50292 }
50293
50294
50295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
50296   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50297   void (*arg2)() = (void (*)()) 0 ;
50298
50299   arg1 = (Dali::Signal< void () > *)jarg1;
50300   arg2 = (void (*)())jarg2;
50301   {
50302     try {
50303       (arg1)->Disconnect(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_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
50327   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50328   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
50329   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
50330
50331   arg1 = (Dali::Signal< void () > *)jarg1;
50332   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
50333   arg3 = (Dali::FunctorDelegate *)jarg3;
50334   {
50335     try {
50336       (arg1)->Connect(arg2,arg3);
50337     } catch (std::out_of_range& e) {
50338       {
50339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50340       };
50341     } catch (std::exception& e) {
50342       {
50343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50344       };
50345     } catch (Dali::DaliException e) {
50346       {
50347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50348       };
50349     } catch (...) {
50350       {
50351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50352       };
50353     }
50354   }
50355
50356 }
50357
50358
50359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
50360   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50361
50362   arg1 = (Dali::Signal< void () > *)jarg1;
50363   {
50364     try {
50365       (arg1)->Emit();
50366     } catch (std::out_of_range& e) {
50367       {
50368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50369       };
50370     } catch (std::exception& e) {
50371       {
50372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50373       };
50374     } catch (Dali::DaliException e) {
50375       {
50376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50377       };
50378     } catch (...) {
50379       {
50380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50381       };
50382     }
50383   }
50384
50385 }
50386
50387
50388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
50389   unsigned int jresult ;
50390   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50391   bool result;
50392
50393   arg1 = (Dali::Signal< void (float) > *)jarg1;
50394   {
50395     try {
50396       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
50397     } catch (std::out_of_range& e) {
50398       {
50399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50400       };
50401     } catch (std::exception& e) {
50402       {
50403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50404       };
50405     } catch (Dali::DaliException e) {
50406       {
50407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50408       };
50409     } catch (...) {
50410       {
50411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50412       };
50413     }
50414   }
50415
50416   jresult = result;
50417   return jresult;
50418 }
50419
50420
50421 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
50422   unsigned long jresult ;
50423   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50424   std::size_t result;
50425
50426   arg1 = (Dali::Signal< void (float) > *)jarg1;
50427   {
50428     try {
50429       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
50430     } catch (std::out_of_range& e) {
50431       {
50432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50433       };
50434     } catch (std::exception& e) {
50435       {
50436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50437       };
50438     } catch (Dali::DaliException e) {
50439       {
50440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50441       };
50442     } catch (...) {
50443       {
50444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50445       };
50446     }
50447   }
50448
50449   jresult = (unsigned long)result;
50450   return jresult;
50451 }
50452
50453
50454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
50455   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50456   void (*arg2)(float) = (void (*)(float)) 0 ;
50457
50458   arg1 = (Dali::Signal< void (float) > *)jarg1;
50459   arg2 = (void (*)(float))jarg2;
50460   {
50461     try {
50462       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
50463     } catch (std::out_of_range& e) {
50464       {
50465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50466       };
50467     } catch (std::exception& e) {
50468       {
50469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50470       };
50471     } catch (Dali::DaliException e) {
50472       {
50473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50474       };
50475     } catch (...) {
50476       {
50477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50478       };
50479     }
50480   }
50481
50482 }
50483
50484
50485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
50486   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50487   void (*arg2)(float) = (void (*)(float)) 0 ;
50488
50489   arg1 = (Dali::Signal< void (float) > *)jarg1;
50490   arg2 = (void (*)(float))jarg2;
50491   {
50492     try {
50493       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
50494     } catch (std::out_of_range& e) {
50495       {
50496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50497       };
50498     } catch (std::exception& e) {
50499       {
50500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50501       };
50502     } catch (Dali::DaliException e) {
50503       {
50504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50505       };
50506     } catch (...) {
50507       {
50508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50509       };
50510     }
50511   }
50512
50513 }
50514
50515
50516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
50517   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50518   float arg2 ;
50519
50520   arg1 = (Dali::Signal< void (float) > *)jarg1;
50521   arg2 = (float)jarg2;
50522   {
50523     try {
50524       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
50525     } catch (std::out_of_range& e) {
50526       {
50527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50528       };
50529     } catch (std::exception& e) {
50530       {
50531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50532       };
50533     } catch (Dali::DaliException e) {
50534       {
50535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50536       };
50537     } catch (...) {
50538       {
50539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50540       };
50541     }
50542   }
50543
50544 }
50545
50546
50547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
50548   void * jresult ;
50549   Dali::Signal< void (float) > *result = 0 ;
50550
50551   {
50552     try {
50553       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
50554     } catch (std::out_of_range& e) {
50555       {
50556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50557       };
50558     } catch (std::exception& e) {
50559       {
50560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50561       };
50562     } catch (Dali::DaliException e) {
50563       {
50564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50565       };
50566     } catch (...) {
50567       {
50568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50569       };
50570     }
50571   }
50572
50573   jresult = (void *)result;
50574   return jresult;
50575 }
50576
50577
50578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
50579   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50580
50581   arg1 = (Dali::Signal< void (float) > *)jarg1;
50582   {
50583     try {
50584       delete arg1;
50585     } catch (std::out_of_range& e) {
50586       {
50587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50588       };
50589     } catch (std::exception& e) {
50590       {
50591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50592       };
50593     } catch (Dali::DaliException e) {
50594       {
50595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50596       };
50597     } catch (...) {
50598       {
50599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50600       };
50601     }
50602   }
50603
50604 }
50605
50606
50607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
50608   unsigned int jresult ;
50609   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50610   bool result;
50611
50612   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50613   {
50614     try {
50615       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50616     } catch (std::out_of_range& e) {
50617       {
50618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50619       };
50620     } catch (std::exception& e) {
50621       {
50622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50623       };
50624     } catch (Dali::DaliException e) {
50625       {
50626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50627       };
50628     } catch (...) {
50629       {
50630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50631       };
50632     }
50633   }
50634
50635   jresult = result;
50636   return jresult;
50637 }
50638
50639
50640 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
50641   unsigned long jresult ;
50642   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50643   std::size_t result;
50644
50645   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50646   {
50647     try {
50648       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50649     } catch (std::out_of_range& e) {
50650       {
50651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50652       };
50653     } catch (std::exception& e) {
50654       {
50655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50656       };
50657     } catch (Dali::DaliException e) {
50658       {
50659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50660       };
50661     } catch (...) {
50662       {
50663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50664       };
50665     }
50666   }
50667
50668   jresult = (unsigned long)result;
50669   return jresult;
50670 }
50671
50672
50673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
50674   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50675   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50676
50677   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50678   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50679   {
50680     try {
50681       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
50682     } catch (std::out_of_range& e) {
50683       {
50684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50685       };
50686     } catch (std::exception& e) {
50687       {
50688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50689       };
50690     } catch (Dali::DaliException e) {
50691       {
50692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50693       };
50694     } catch (...) {
50695       {
50696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50697       };
50698     }
50699   }
50700
50701 }
50702
50703
50704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
50705   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50706   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50707
50708   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50709   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50710   {
50711     try {
50712       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
50713     } catch (std::out_of_range& e) {
50714       {
50715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50716       };
50717     } catch (std::exception& e) {
50718       {
50719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50720       };
50721     } catch (Dali::DaliException e) {
50722       {
50723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50724       };
50725     } catch (...) {
50726       {
50727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50728       };
50729     }
50730   }
50731
50732 }
50733
50734
50735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
50736   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50737   Dali::BaseHandle arg2 ;
50738   Dali::BaseHandle *argp2 ;
50739
50740   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50741   argp2 = (Dali::BaseHandle *)jarg2;
50742   if (!argp2) {
50743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50744     return ;
50745   }
50746   arg2 = *argp2;
50747   {
50748     try {
50749       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
50750     } catch (std::out_of_range& e) {
50751       {
50752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50753       };
50754     } catch (std::exception& e) {
50755       {
50756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50757       };
50758     } catch (Dali::DaliException e) {
50759       {
50760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50761       };
50762     } catch (...) {
50763       {
50764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50765       };
50766     }
50767   }
50768
50769 }
50770
50771
50772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
50773   void * jresult ;
50774   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
50775
50776   {
50777     try {
50778       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
50779     } catch (std::out_of_range& e) {
50780       {
50781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50782       };
50783     } catch (std::exception& e) {
50784       {
50785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50786       };
50787     } catch (Dali::DaliException e) {
50788       {
50789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50790       };
50791     } catch (...) {
50792       {
50793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50794       };
50795     }
50796   }
50797
50798   jresult = (void *)result;
50799   return jresult;
50800 }
50801
50802
50803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
50804   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50805
50806   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50807   {
50808     try {
50809       delete arg1;
50810     } catch (std::out_of_range& e) {
50811       {
50812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50813       };
50814     } catch (std::exception& e) {
50815       {
50816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50817       };
50818     } catch (Dali::DaliException e) {
50819       {
50820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50821       };
50822     } catch (...) {
50823       {
50824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50825       };
50826     }
50827   }
50828
50829 }
50830
50831
50832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
50833   unsigned int jresult ;
50834   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50835   bool result;
50836
50837   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50838   {
50839     try {
50840       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
50841     } catch (std::out_of_range& e) {
50842       {
50843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50844       };
50845     } catch (std::exception& e) {
50846       {
50847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50848       };
50849     } catch (Dali::DaliException e) {
50850       {
50851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50852       };
50853     } catch (...) {
50854       {
50855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50856       };
50857     }
50858   }
50859
50860   jresult = result;
50861   return jresult;
50862 }
50863
50864
50865 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
50866   unsigned long jresult ;
50867   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50868   std::size_t result;
50869
50870   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50871   {
50872     try {
50873       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
50874     } catch (std::out_of_range& e) {
50875       {
50876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50877       };
50878     } catch (std::exception& e) {
50879       {
50880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50881       };
50882     } catch (Dali::DaliException e) {
50883       {
50884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50885       };
50886     } catch (...) {
50887       {
50888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50889       };
50890     }
50891   }
50892
50893   jresult = (unsigned long)result;
50894   return jresult;
50895 }
50896
50897
50898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
50899   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50900   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
50901
50902   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50903   arg2 = (void (*)(Dali::RefObject const *))jarg2;
50904   {
50905     try {
50906       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
50907     } catch (std::out_of_range& e) {
50908       {
50909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50910       };
50911     } catch (std::exception& e) {
50912       {
50913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50914       };
50915     } catch (Dali::DaliException e) {
50916       {
50917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50918       };
50919     } catch (...) {
50920       {
50921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50922       };
50923     }
50924   }
50925
50926 }
50927
50928
50929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
50930   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50931   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
50932
50933   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50934   arg2 = (void (*)(Dali::RefObject const *))jarg2;
50935   {
50936     try {
50937       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
50938     } catch (std::out_of_range& e) {
50939       {
50940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50941       };
50942     } catch (std::exception& e) {
50943       {
50944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50945       };
50946     } catch (Dali::DaliException e) {
50947       {
50948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50949       };
50950     } catch (...) {
50951       {
50952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50953       };
50954     }
50955   }
50956
50957 }
50958
50959
50960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
50961   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50962   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
50963
50964   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50965   arg2 = (Dali::RefObject *)jarg2;
50966   {
50967     try {
50968       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
50969     } catch (std::out_of_range& e) {
50970       {
50971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50972       };
50973     } catch (std::exception& e) {
50974       {
50975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50976       };
50977     } catch (Dali::DaliException e) {
50978       {
50979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50980       };
50981     } catch (...) {
50982       {
50983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50984       };
50985     }
50986   }
50987
50988 }
50989
50990
50991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
50992   void * jresult ;
50993   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
50994
50995   {
50996     try {
50997       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
50998     } catch (std::out_of_range& e) {
50999       {
51000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51001       };
51002     } catch (std::exception& e) {
51003       {
51004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51005       };
51006     } catch (Dali::DaliException e) {
51007       {
51008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51009       };
51010     } catch (...) {
51011       {
51012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51013       };
51014     }
51015   }
51016
51017   jresult = (void *)result;
51018   return jresult;
51019 }
51020
51021
51022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
51023   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51024
51025   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51026   {
51027     try {
51028       delete arg1;
51029     } catch (std::out_of_range& e) {
51030       {
51031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51032       };
51033     } catch (std::exception& e) {
51034       {
51035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51036       };
51037     } catch (Dali::DaliException e) {
51038       {
51039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51040       };
51041     } catch (...) {
51042       {
51043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51044       };
51045     }
51046   }
51047
51048 }
51049
51050
51051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
51052   unsigned int jresult ;
51053   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51054   bool result;
51055
51056   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51057   {
51058     try {
51059       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51060     } catch (std::out_of_range& e) {
51061       {
51062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51063       };
51064     } catch (std::exception& e) {
51065       {
51066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51067       };
51068     } catch (Dali::DaliException e) {
51069       {
51070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51071       };
51072     } catch (...) {
51073       {
51074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51075       };
51076     }
51077   }
51078
51079   jresult = result;
51080   return jresult;
51081 }
51082
51083
51084 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
51085   unsigned long jresult ;
51086   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51087   std::size_t result;
51088
51089   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51090   {
51091     try {
51092       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51093     } catch (std::out_of_range& e) {
51094       {
51095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51096       };
51097     } catch (std::exception& e) {
51098       {
51099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51100       };
51101     } catch (Dali::DaliException e) {
51102       {
51103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51104       };
51105     } catch (...) {
51106       {
51107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51108       };
51109     }
51110   }
51111
51112   jresult = (unsigned long)result;
51113   return jresult;
51114 }
51115
51116
51117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
51118   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51119   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51120
51121   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51122   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51123   {
51124     try {
51125       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
51126     } catch (std::out_of_range& e) {
51127       {
51128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51129       };
51130     } catch (std::exception& e) {
51131       {
51132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51133       };
51134     } catch (Dali::DaliException e) {
51135       {
51136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51137       };
51138     } catch (...) {
51139       {
51140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51141       };
51142     }
51143   }
51144
51145 }
51146
51147
51148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
51149   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51150   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51151
51152   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51153   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51154   {
51155     try {
51156       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
51157     } catch (std::out_of_range& e) {
51158       {
51159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51160       };
51161     } catch (std::exception& e) {
51162       {
51163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51164       };
51165     } catch (Dali::DaliException e) {
51166       {
51167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51168       };
51169     } catch (...) {
51170       {
51171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51172       };
51173     }
51174   }
51175
51176 }
51177
51178
51179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
51180   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51181   Dali::PropertyNotification *arg2 = 0 ;
51182
51183   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51184   arg2 = (Dali::PropertyNotification *)jarg2;
51185   if (!arg2) {
51186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
51187     return ;
51188   }
51189   {
51190     try {
51191       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
51192     } catch (std::out_of_range& e) {
51193       {
51194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51195       };
51196     } catch (std::exception& e) {
51197       {
51198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51199       };
51200     } catch (Dali::DaliException e) {
51201       {
51202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51203       };
51204     } catch (...) {
51205       {
51206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51207       };
51208     }
51209   }
51210
51211 }
51212
51213
51214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
51215   void * jresult ;
51216   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
51217
51218   {
51219     try {
51220       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
51221     } catch (std::out_of_range& e) {
51222       {
51223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51224       };
51225     } catch (std::exception& e) {
51226       {
51227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51228       };
51229     } catch (Dali::DaliException e) {
51230       {
51231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51232       };
51233     } catch (...) {
51234       {
51235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51236       };
51237     }
51238   }
51239
51240   jresult = (void *)result;
51241   return jresult;
51242 }
51243
51244
51245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
51246   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51247
51248   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51249   {
51250     try {
51251       delete arg1;
51252     } catch (std::out_of_range& e) {
51253       {
51254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51255       };
51256     } catch (std::exception& e) {
51257       {
51258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51259       };
51260     } catch (Dali::DaliException e) {
51261       {
51262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51263       };
51264     } catch (...) {
51265       {
51266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51267       };
51268     }
51269   }
51270
51271 }
51272
51273
51274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
51275   void * jresult ;
51276   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
51277
51278   {
51279     try {
51280       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
51281     } catch (std::out_of_range& e) {
51282       {
51283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51284       };
51285     } catch (std::exception& e) {
51286       {
51287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51288       };
51289     } catch (Dali::DaliException e) {
51290       {
51291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51292       };
51293     } catch (...) {
51294       {
51295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51296       };
51297     }
51298   }
51299
51300   jresult = (void *)result;
51301   return jresult;
51302 }
51303
51304
51305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
51306   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
51307
51308   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
51309   {
51310     try {
51311       delete arg1;
51312     } catch (std::out_of_range& e) {
51313       {
51314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51315       };
51316     } catch (std::exception& e) {
51317       {
51318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51319       };
51320     } catch (Dali::DaliException e) {
51321       {
51322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51323       };
51324     } catch (...) {
51325       {
51326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51327       };
51328     }
51329   }
51330
51331 }
51332
51333
51334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
51335   unsigned int jresult ;
51336   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51337   bool result;
51338
51339   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51340   {
51341     try {
51342       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);
51343     } catch (std::out_of_range& e) {
51344       {
51345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51346       };
51347     } catch (std::exception& e) {
51348       {
51349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51350       };
51351     } catch (Dali::DaliException e) {
51352       {
51353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51354       };
51355     } catch (...) {
51356       {
51357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51358       };
51359     }
51360   }
51361
51362   jresult = result;
51363   return jresult;
51364 }
51365
51366
51367 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51368   unsigned long jresult ;
51369   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51370   std::size_t result;
51371
51372   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51373   {
51374     try {
51375       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);
51376     } catch (std::out_of_range& e) {
51377       {
51378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51379       };
51380     } catch (std::exception& e) {
51381       {
51382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51383       };
51384     } catch (Dali::DaliException e) {
51385       {
51386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51387       };
51388     } catch (...) {
51389       {
51390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51391       };
51392     }
51393   }
51394
51395   jresult = (unsigned long)result;
51396   return jresult;
51397 }
51398
51399
51400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51401   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51402   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51403
51404   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51405   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51406   {
51407     try {
51408       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51409     } catch (std::out_of_range& e) {
51410       {
51411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51412       };
51413     } catch (std::exception& e) {
51414       {
51415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51416       };
51417     } catch (Dali::DaliException e) {
51418       {
51419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51420       };
51421     } catch (...) {
51422       {
51423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51424       };
51425     }
51426   }
51427
51428 }
51429
51430
51431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51432   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51433   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51434
51435   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51436   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51437   {
51438     try {
51439       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51440     } catch (std::out_of_range& e) {
51441       {
51442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51443       };
51444     } catch (std::exception& e) {
51445       {
51446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51447       };
51448     } catch (Dali::DaliException e) {
51449       {
51450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51451       };
51452     } catch (...) {
51453       {
51454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51455       };
51456     }
51457   }
51458
51459 }
51460
51461
51462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51463   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51464   Dali::Actor arg2 ;
51465   Dali::LongPressGesture *arg3 = 0 ;
51466   Dali::Actor *argp2 ;
51467
51468   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51469   argp2 = (Dali::Actor *)jarg2;
51470   if (!argp2) {
51471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51472     return ;
51473   }
51474   arg2 = *argp2;
51475   arg3 = (Dali::LongPressGesture *)jarg3;
51476   if (!arg3) {
51477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
51478     return ;
51479   }
51480   {
51481     try {
51482       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
51483     } catch (std::out_of_range& e) {
51484       {
51485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51486       };
51487     } catch (std::exception& e) {
51488       {
51489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51490       };
51491     } catch (Dali::DaliException e) {
51492       {
51493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51494       };
51495     } catch (...) {
51496       {
51497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51498       };
51499     }
51500   }
51501
51502 }
51503
51504
51505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
51506   void * jresult ;
51507   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
51508
51509   {
51510     try {
51511       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
51512     } catch (std::out_of_range& e) {
51513       {
51514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51515       };
51516     } catch (std::exception& e) {
51517       {
51518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51519       };
51520     } catch (Dali::DaliException e) {
51521       {
51522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51523       };
51524     } catch (...) {
51525       {
51526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51527       };
51528     }
51529   }
51530
51531   jresult = (void *)result;
51532   return jresult;
51533 }
51534
51535
51536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
51537   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51538
51539   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51540   {
51541     try {
51542       delete arg1;
51543     } catch (std::out_of_range& e) {
51544       {
51545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51546       };
51547     } catch (std::exception& e) {
51548       {
51549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51550       };
51551     } catch (Dali::DaliException e) {
51552       {
51553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51554       };
51555     } catch (...) {
51556       {
51557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51558       };
51559     }
51560   }
51561
51562 }
51563
51564
51565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
51566   unsigned int jresult ;
51567   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51568   bool result;
51569
51570   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51571   {
51572     try {
51573       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *)arg1);
51574     } catch (std::out_of_range& e) {
51575       {
51576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51577       };
51578     } catch (std::exception& e) {
51579       {
51580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51581       };
51582     } catch (Dali::DaliException e) {
51583       {
51584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51585       };
51586     } catch (...) {
51587       {
51588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51589       };
51590     }
51591   }
51592
51593   jresult = result;
51594   return jresult;
51595 }
51596
51597
51598 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
51599   unsigned long jresult ;
51600   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51601   std::size_t result;
51602
51603   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51604   {
51605     try {
51606       result = Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > const *)arg1);
51607     } catch (std::out_of_range& e) {
51608       {
51609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51610       };
51611     } catch (std::exception& e) {
51612       {
51613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51614       };
51615     } catch (Dali::DaliException e) {
51616       {
51617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51618       };
51619     } catch (...) {
51620       {
51621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51622       };
51623     }
51624   }
51625
51626   jresult = (unsigned long)result;
51627   return jresult;
51628 }
51629
51630
51631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
51632   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51633   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
51634
51635   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51636   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
51637   {
51638     try {
51639       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51640     } catch (std::out_of_range& e) {
51641       {
51642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51643       };
51644     } catch (std::exception& e) {
51645       {
51646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51647       };
51648     } catch (Dali::DaliException e) {
51649       {
51650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51651       };
51652     } catch (...) {
51653       {
51654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51655       };
51656     }
51657   }
51658
51659 }
51660
51661
51662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
51663   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51664   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
51665
51666   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51667   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
51668   {
51669     try {
51670       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51671     } catch (std::out_of_range& e) {
51672       {
51673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51674       };
51675     } catch (std::exception& e) {
51676       {
51677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51678       };
51679     } catch (Dali::DaliException e) {
51680       {
51681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51682       };
51683     } catch (...) {
51684       {
51685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51686       };
51687     }
51688   }
51689
51690 }
51691
51692
51693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51694   unsigned int jresult ;
51695   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51696   Dali::Actor arg2 ;
51697   Dali::TouchEvent *arg3 = 0 ;
51698   Dali::Actor *argp2 ;
51699   bool result;
51700
51701   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51702   argp2 = (Dali::Actor *)jarg2;
51703   if (!argp2) {
51704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51705     return 0;
51706   }
51707   arg2 = *argp2;
51708   arg3 = (Dali::TouchEvent *)jarg3;
51709   if (!arg3) {
51710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
51711     return 0;
51712   }
51713   {
51714     try {
51715       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
51716     } catch (std::out_of_range& e) {
51717       {
51718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51719       };
51720     } catch (std::exception& e) {
51721       {
51722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51723       };
51724     } catch (Dali::DaliException e) {
51725       {
51726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51727       };
51728     } catch (...) {
51729       {
51730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51731       };
51732     }
51733   }
51734
51735   jresult = result;
51736   return jresult;
51737 }
51738
51739
51740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
51741   void * jresult ;
51742   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
51743
51744   {
51745     try {
51746       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
51747     } catch (std::out_of_range& e) {
51748       {
51749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51750       };
51751     } catch (std::exception& e) {
51752       {
51753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51754       };
51755     } catch (Dali::DaliException e) {
51756       {
51757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51758       };
51759     } catch (...) {
51760       {
51761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51762       };
51763     }
51764   }
51765
51766   jresult = (void *)result;
51767   return jresult;
51768 }
51769
51770
51771 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
51772   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51773
51774   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51775   {
51776     try {
51777       delete arg1;
51778     } catch (std::out_of_range& e) {
51779       {
51780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51781       };
51782     } catch (std::exception& e) {
51783       {
51784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51785       };
51786     } catch (Dali::DaliException e) {
51787       {
51788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51789       };
51790     } catch (...) {
51791       {
51792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51793       };
51794     }
51795   }
51796
51797 }
51798
51799
51800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
51801   unsigned int jresult ;
51802   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51803   bool result;
51804
51805   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51806   {
51807     try {
51808       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);
51809     } catch (std::out_of_range& e) {
51810       {
51811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51812       };
51813     } catch (std::exception& e) {
51814       {
51815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51816       };
51817     } catch (Dali::DaliException e) {
51818       {
51819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51820       };
51821     } catch (...) {
51822       {
51823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51824       };
51825     }
51826   }
51827
51828   jresult = result;
51829   return jresult;
51830 }
51831
51832
51833 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
51834   unsigned long jresult ;
51835   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51836   std::size_t result;
51837
51838   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51839   {
51840     try {
51841       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);
51842     } catch (std::out_of_range& e) {
51843       {
51844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51845       };
51846     } catch (std::exception& e) {
51847       {
51848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51849       };
51850     } catch (Dali::DaliException e) {
51851       {
51852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51853       };
51854     } catch (...) {
51855       {
51856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51857       };
51858     }
51859   }
51860
51861   jresult = (unsigned long)result;
51862   return jresult;
51863 }
51864
51865
51866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
51867   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51868   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
51869
51870   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51871   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
51872   {
51873     try {
51874       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51875     } catch (std::out_of_range& e) {
51876       {
51877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51878       };
51879     } catch (std::exception& e) {
51880       {
51881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51882       };
51883     } catch (Dali::DaliException e) {
51884       {
51885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51886       };
51887     } catch (...) {
51888       {
51889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51890       };
51891     }
51892   }
51893
51894 }
51895
51896
51897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
51898   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51899   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
51900
51901   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51902   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
51903   {
51904     try {
51905       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51906     } catch (std::out_of_range& e) {
51907       {
51908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51909       };
51910     } catch (std::exception& e) {
51911       {
51912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51913       };
51914     } catch (Dali::DaliException e) {
51915       {
51916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51917       };
51918     } catch (...) {
51919       {
51920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51921       };
51922     }
51923   }
51924
51925 }
51926
51927
51928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51929   unsigned int jresult ;
51930   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51931   Dali::Actor arg2 ;
51932   Dali::HoverEvent *arg3 = 0 ;
51933   Dali::Actor *argp2 ;
51934   bool result;
51935
51936   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51937   argp2 = (Dali::Actor *)jarg2;
51938   if (!argp2) {
51939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51940     return 0;
51941   }
51942   arg2 = *argp2;
51943   arg3 = (Dali::HoverEvent *)jarg3;
51944   if (!arg3) {
51945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
51946     return 0;
51947   }
51948   {
51949     try {
51950       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
51951     } catch (std::out_of_range& e) {
51952       {
51953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51954       };
51955     } catch (std::exception& e) {
51956       {
51957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51958       };
51959     } catch (Dali::DaliException e) {
51960       {
51961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51962       };
51963     } catch (...) {
51964       {
51965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51966       };
51967     }
51968   }
51969
51970   jresult = result;
51971   return jresult;
51972 }
51973
51974
51975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
51976   void * jresult ;
51977   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
51978
51979   {
51980     try {
51981       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
51982     } catch (std::out_of_range& e) {
51983       {
51984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51985       };
51986     } catch (std::exception& e) {
51987       {
51988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51989       };
51990     } catch (Dali::DaliException e) {
51991       {
51992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51993       };
51994     } catch (...) {
51995       {
51996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51997       };
51998     }
51999   }
52000
52001   jresult = (void *)result;
52002   return jresult;
52003 }
52004
52005
52006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
52007   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52008
52009   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52010   {
52011     try {
52012       delete arg1;
52013     } catch (std::out_of_range& e) {
52014       {
52015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52016       };
52017     } catch (std::exception& e) {
52018       {
52019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52020       };
52021     } catch (Dali::DaliException e) {
52022       {
52023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52024       };
52025     } catch (...) {
52026       {
52027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52028       };
52029     }
52030   }
52031
52032 }
52033
52034
52035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
52036   unsigned int jresult ;
52037   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52038   bool result;
52039
52040   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52041   {
52042     try {
52043       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);
52044     } catch (std::out_of_range& e) {
52045       {
52046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52047       };
52048     } catch (std::exception& e) {
52049       {
52050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52051       };
52052     } catch (Dali::DaliException e) {
52053       {
52054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52055       };
52056     } catch (...) {
52057       {
52058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52059       };
52060     }
52061   }
52062
52063   jresult = result;
52064   return jresult;
52065 }
52066
52067
52068 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
52069   unsigned long jresult ;
52070   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52071   std::size_t result;
52072
52073   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52074   {
52075     try {
52076       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);
52077     } catch (std::out_of_range& e) {
52078       {
52079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52080       };
52081     } catch (std::exception& e) {
52082       {
52083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52084       };
52085     } catch (Dali::DaliException e) {
52086       {
52087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52088       };
52089     } catch (...) {
52090       {
52091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52092       };
52093     }
52094   }
52095
52096   jresult = (unsigned long)result;
52097   return jresult;
52098 }
52099
52100
52101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
52102   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52103   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52104
52105   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52106   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52107   {
52108     try {
52109       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52110     } catch (std::out_of_range& e) {
52111       {
52112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52113       };
52114     } catch (std::exception& e) {
52115       {
52116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52117       };
52118     } catch (Dali::DaliException e) {
52119       {
52120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52121       };
52122     } catch (...) {
52123       {
52124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52125       };
52126     }
52127   }
52128
52129 }
52130
52131
52132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
52133   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52134   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52135
52136   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52137   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52138   {
52139     try {
52140       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52141     } catch (std::out_of_range& e) {
52142       {
52143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52144       };
52145     } catch (std::exception& e) {
52146       {
52147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52148       };
52149     } catch (Dali::DaliException e) {
52150       {
52151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52152       };
52153     } catch (...) {
52154       {
52155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52156       };
52157     }
52158   }
52159
52160 }
52161
52162
52163 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52164   unsigned int jresult ;
52165   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52166   Dali::Actor arg2 ;
52167   Dali::WheelEvent *arg3 = 0 ;
52168   Dali::Actor *argp2 ;
52169   bool result;
52170
52171   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52172   argp2 = (Dali::Actor *)jarg2;
52173   if (!argp2) {
52174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52175     return 0;
52176   }
52177   arg2 = *argp2;
52178   arg3 = (Dali::WheelEvent *)jarg3;
52179   if (!arg3) {
52180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
52181     return 0;
52182   }
52183   {
52184     try {
52185       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
52186     } catch (std::out_of_range& e) {
52187       {
52188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52189       };
52190     } catch (std::exception& e) {
52191       {
52192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52193       };
52194     } catch (Dali::DaliException e) {
52195       {
52196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52197       };
52198     } catch (...) {
52199       {
52200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52201       };
52202     }
52203   }
52204
52205   jresult = result;
52206   return jresult;
52207 }
52208
52209
52210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
52211   void * jresult ;
52212   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
52213
52214   {
52215     try {
52216       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
52217     } catch (std::out_of_range& e) {
52218       {
52219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52220       };
52221     } catch (std::exception& e) {
52222       {
52223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52224       };
52225     } catch (Dali::DaliException e) {
52226       {
52227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52228       };
52229     } catch (...) {
52230       {
52231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52232       };
52233     }
52234   }
52235
52236   jresult = (void *)result;
52237   return jresult;
52238 }
52239
52240
52241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
52242   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52243
52244   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52245   {
52246     try {
52247       delete arg1;
52248     } catch (std::out_of_range& e) {
52249       {
52250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52251       };
52252     } catch (std::exception& e) {
52253       {
52254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52255       };
52256     } catch (Dali::DaliException e) {
52257       {
52258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52259       };
52260     } catch (...) {
52261       {
52262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52263       };
52264     }
52265   }
52266
52267 }
52268
52269
52270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
52271   unsigned int jresult ;
52272   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52273   bool result;
52274
52275   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52276   {
52277     try {
52278       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
52279     } catch (std::out_of_range& e) {
52280       {
52281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52282       };
52283     } catch (std::exception& e) {
52284       {
52285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52286       };
52287     } catch (Dali::DaliException e) {
52288       {
52289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52290       };
52291     } catch (...) {
52292       {
52293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52294       };
52295     }
52296   }
52297
52298   jresult = result;
52299   return jresult;
52300 }
52301
52302
52303 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
52304   unsigned long jresult ;
52305   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52306   std::size_t result;
52307
52308   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52309   {
52310     try {
52311       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
52312     } catch (std::out_of_range& e) {
52313       {
52314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52315       };
52316     } catch (std::exception& e) {
52317       {
52318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52319       };
52320     } catch (Dali::DaliException e) {
52321       {
52322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52323       };
52324     } catch (...) {
52325       {
52326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52327       };
52328     }
52329   }
52330
52331   jresult = (unsigned long)result;
52332   return jresult;
52333 }
52334
52335
52336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
52337   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52338   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52339
52340   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52341   arg2 = (void (*)(Dali::Actor))jarg2;
52342   {
52343     try {
52344       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
52345     } catch (std::out_of_range& e) {
52346       {
52347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52348       };
52349     } catch (std::exception& e) {
52350       {
52351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52352       };
52353     } catch (Dali::DaliException e) {
52354       {
52355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52356       };
52357     } catch (...) {
52358       {
52359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52360       };
52361     }
52362   }
52363
52364 }
52365
52366
52367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
52368   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52369   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52370
52371   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52372   arg2 = (void (*)(Dali::Actor))jarg2;
52373   {
52374     try {
52375       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
52376     } catch (std::out_of_range& e) {
52377       {
52378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52379       };
52380     } catch (std::exception& e) {
52381       {
52382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52383       };
52384     } catch (Dali::DaliException e) {
52385       {
52386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52387       };
52388     } catch (...) {
52389       {
52390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52391       };
52392     }
52393   }
52394
52395 }
52396
52397
52398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
52399   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52400   Dali::Actor arg2 ;
52401   Dali::Actor *argp2 ;
52402
52403   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52404   argp2 = (Dali::Actor *)jarg2;
52405   if (!argp2) {
52406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52407     return ;
52408   }
52409   arg2 = *argp2;
52410   {
52411     try {
52412       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
52413     } catch (std::out_of_range& e) {
52414       {
52415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52416       };
52417     } catch (std::exception& e) {
52418       {
52419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52420       };
52421     } catch (Dali::DaliException e) {
52422       {
52423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52424       };
52425     } catch (...) {
52426       {
52427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52428       };
52429     }
52430   }
52431
52432 }
52433
52434
52435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
52436   void * jresult ;
52437   Dali::Signal< void (Dali::Actor) > *result = 0 ;
52438
52439   {
52440     try {
52441       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
52442     } catch (std::out_of_range& e) {
52443       {
52444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52445       };
52446     } catch (std::exception& e) {
52447       {
52448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52449       };
52450     } catch (Dali::DaliException e) {
52451       {
52452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52453       };
52454     } catch (...) {
52455       {
52456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52457       };
52458     }
52459   }
52460
52461   jresult = (void *)result;
52462   return jresult;
52463 }
52464
52465
52466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
52467   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52468
52469   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52470   {
52471     try {
52472       delete arg1;
52473     } catch (std::out_of_range& e) {
52474       {
52475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52476       };
52477     } catch (std::exception& e) {
52478       {
52479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52480       };
52481     } catch (Dali::DaliException e) {
52482       {
52483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52484       };
52485     } catch (...) {
52486       {
52487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52488       };
52489     }
52490   }
52491
52492 }
52493
52494
52495 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
52496   unsigned int jresult ;
52497   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52498   bool result;
52499
52500   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52501   {
52502     try {
52503       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52504     } catch (std::out_of_range& e) {
52505       {
52506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52507       };
52508     } catch (std::exception& e) {
52509       {
52510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52511       };
52512     } catch (Dali::DaliException e) {
52513       {
52514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52515       };
52516     } catch (...) {
52517       {
52518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52519       };
52520     }
52521   }
52522
52523   jresult = result;
52524   return jresult;
52525 }
52526
52527
52528 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
52529   unsigned long jresult ;
52530   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52531   std::size_t result;
52532
52533   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52534   {
52535     try {
52536       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52537     } catch (std::out_of_range& e) {
52538       {
52539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52540       };
52541     } catch (std::exception& e) {
52542       {
52543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52544       };
52545     } catch (Dali::DaliException e) {
52546       {
52547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52548       };
52549     } catch (...) {
52550       {
52551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52552       };
52553     }
52554   }
52555
52556   jresult = (unsigned long)result;
52557   return jresult;
52558 }
52559
52560
52561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
52562   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52563   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52564
52565   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52566   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52567   {
52568     try {
52569       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52570     } catch (std::out_of_range& e) {
52571       {
52572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52573       };
52574     } catch (std::exception& e) {
52575       {
52576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52577       };
52578     } catch (Dali::DaliException e) {
52579       {
52580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52581       };
52582     } catch (...) {
52583       {
52584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52585       };
52586     }
52587   }
52588
52589 }
52590
52591
52592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
52593   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52594   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52595
52596   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52597   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52598   {
52599     try {
52600       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52601     } catch (std::out_of_range& e) {
52602       {
52603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52604       };
52605     } catch (std::exception& e) {
52606       {
52607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52608       };
52609     } catch (Dali::DaliException e) {
52610       {
52611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52612       };
52613     } catch (...) {
52614       {
52615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52616       };
52617     }
52618   }
52619
52620 }
52621
52622
52623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
52624   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52625   Dali::KeyEvent *arg2 = 0 ;
52626
52627   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52628   arg2 = (Dali::KeyEvent *)jarg2;
52629   if (!arg2) {
52630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
52631     return ;
52632   }
52633   {
52634     try {
52635       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
52636     } catch (std::out_of_range& e) {
52637       {
52638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52639       };
52640     } catch (std::exception& e) {
52641       {
52642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52643       };
52644     } catch (Dali::DaliException e) {
52645       {
52646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52647       };
52648     } catch (...) {
52649       {
52650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52651       };
52652     }
52653   }
52654
52655 }
52656
52657
52658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
52659   void * jresult ;
52660   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
52661
52662   {
52663     try {
52664       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
52665     } catch (std::out_of_range& e) {
52666       {
52667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52668       };
52669     } catch (std::exception& e) {
52670       {
52671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52672       };
52673     } catch (Dali::DaliException e) {
52674       {
52675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52676       };
52677     } catch (...) {
52678       {
52679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52680       };
52681     }
52682   }
52683
52684   jresult = (void *)result;
52685   return jresult;
52686 }
52687
52688
52689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
52690   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52691
52692   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52693   {
52694     try {
52695       delete arg1;
52696     } catch (std::out_of_range& e) {
52697       {
52698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52699       };
52700     } catch (std::exception& e) {
52701       {
52702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52703       };
52704     } catch (Dali::DaliException e) {
52705       {
52706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52707       };
52708     } catch (...) {
52709       {
52710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52711       };
52712     }
52713   }
52714
52715 }
52716
52717
52718 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
52719   unsigned int jresult ;
52720   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
52721   bool result;
52722
52723   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
52724   {
52725     try {
52726       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
52727     } catch (std::out_of_range& e) {
52728       {
52729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52730       };
52731     } catch (std::exception& e) {
52732       {
52733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52734       };
52735     } catch (Dali::DaliException e) {
52736       {
52737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52738       };
52739     } catch (...) {
52740       {
52741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52742       };
52743     }
52744   }
52745
52746   jresult = result;
52747   return jresult;
52748 }
52749
52750
52751 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
52752   unsigned long jresult ;
52753   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
52754   std::size_t result;
52755
52756   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
52757   {
52758     try {
52759       result = Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
52760     } catch (std::out_of_range& e) {
52761       {
52762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52763       };
52764     } catch (std::exception& e) {
52765       {
52766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52767       };
52768     } catch (Dali::DaliException e) {
52769       {
52770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52771       };
52772     } catch (...) {
52773       {
52774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52775       };
52776     }
52777   }
52778
52779   jresult = (unsigned long)result;
52780   return jresult;
52781 }
52782
52783
52784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
52785   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
52786   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
52787
52788   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
52789   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
52790   {
52791     try {
52792       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52793     } catch (std::out_of_range& e) {
52794       {
52795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52796       };
52797     } catch (std::exception& e) {
52798       {
52799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52800       };
52801     } catch (Dali::DaliException e) {
52802       {
52803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52804       };
52805     } catch (...) {
52806       {
52807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52808       };
52809     }
52810   }
52811
52812 }
52813
52814
52815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
52816   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
52817   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
52818
52819   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
52820   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
52821   {
52822     try {
52823       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52824     } catch (std::out_of_range& e) {
52825       {
52826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52827       };
52828     } catch (std::exception& e) {
52829       {
52830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52831       };
52832     } catch (Dali::DaliException e) {
52833       {
52834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52835       };
52836     } catch (...) {
52837       {
52838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52839       };
52840     }
52841   }
52842
52843 }
52844
52845
52846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
52847   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
52848   Dali::TouchEvent *arg2 = 0 ;
52849
52850   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
52851   arg2 = (Dali::TouchEvent *)jarg2;
52852   if (!arg2) {
52853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
52854     return ;
52855   }
52856   {
52857     try {
52858       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchEvent const &)*arg2);
52859     } catch (std::out_of_range& e) {
52860       {
52861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52862       };
52863     } catch (std::exception& e) {
52864       {
52865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52866       };
52867     } catch (Dali::DaliException e) {
52868       {
52869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52870       };
52871     } catch (...) {
52872       {
52873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52874       };
52875     }
52876   }
52877
52878 }
52879
52880
52881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
52882   void * jresult ;
52883   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
52884
52885   {
52886     try {
52887       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
52888     } catch (std::out_of_range& e) {
52889       {
52890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52891       };
52892     } catch (std::exception& e) {
52893       {
52894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52895       };
52896     } catch (Dali::DaliException e) {
52897       {
52898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52899       };
52900     } catch (...) {
52901       {
52902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52903       };
52904     }
52905   }
52906
52907   jresult = (void *)result;
52908   return jresult;
52909 }
52910
52911
52912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
52913   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
52914
52915   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
52916   {
52917     try {
52918       delete arg1;
52919     } catch (std::out_of_range& e) {
52920       {
52921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52922       };
52923     } catch (std::exception& e) {
52924       {
52925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52926       };
52927     } catch (Dali::DaliException e) {
52928       {
52929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52930       };
52931     } catch (...) {
52932       {
52933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52934       };
52935     }
52936   }
52937
52938 }
52939
52940
52941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
52942   unsigned int jresult ;
52943   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52944   bool result;
52945
52946   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52947   {
52948     try {
52949       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
52950     } catch (std::out_of_range& e) {
52951       {
52952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52953       };
52954     } catch (std::exception& e) {
52955       {
52956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52957       };
52958     } catch (Dali::DaliException e) {
52959       {
52960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52961       };
52962     } catch (...) {
52963       {
52964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52965       };
52966     }
52967   }
52968
52969   jresult = result;
52970   return jresult;
52971 }
52972
52973
52974 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
52975   unsigned long jresult ;
52976   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52977   std::size_t result;
52978
52979   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52980   {
52981     try {
52982       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
52983     } catch (std::out_of_range& e) {
52984       {
52985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52986       };
52987     } catch (std::exception& e) {
52988       {
52989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52990       };
52991     } catch (Dali::DaliException e) {
52992       {
52993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52994       };
52995     } catch (...) {
52996       {
52997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52998       };
52999     }
53000   }
53001
53002   jresult = (unsigned long)result;
53003   return jresult;
53004 }
53005
53006
53007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
53008   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53009   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53010
53011   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53012   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53013   {
53014     try {
53015       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53016     } catch (std::out_of_range& e) {
53017       {
53018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53019       };
53020     } catch (std::exception& e) {
53021       {
53022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53023       };
53024     } catch (Dali::DaliException e) {
53025       {
53026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53027       };
53028     } catch (...) {
53029       {
53030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53031       };
53032     }
53033   }
53034
53035 }
53036
53037
53038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
53039   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53040   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53041
53042   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53043   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53044   {
53045     try {
53046       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53047     } catch (std::out_of_range& e) {
53048       {
53049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53050       };
53051     } catch (std::exception& e) {
53052       {
53053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53054       };
53055     } catch (Dali::DaliException e) {
53056       {
53057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53058       };
53059     } catch (...) {
53060       {
53061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53062       };
53063     }
53064   }
53065
53066 }
53067
53068
53069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
53070   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53071   Dali::WheelEvent *arg2 = 0 ;
53072
53073   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53074   arg2 = (Dali::WheelEvent *)jarg2;
53075   if (!arg2) {
53076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
53077     return ;
53078   }
53079   {
53080     try {
53081       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
53082     } catch (std::out_of_range& e) {
53083       {
53084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53085       };
53086     } catch (std::exception& e) {
53087       {
53088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53089       };
53090     } catch (Dali::DaliException e) {
53091       {
53092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53093       };
53094     } catch (...) {
53095       {
53096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53097       };
53098     }
53099   }
53100
53101 }
53102
53103
53104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
53105   void * jresult ;
53106   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
53107
53108   {
53109     try {
53110       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
53111     } catch (std::out_of_range& e) {
53112       {
53113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53114       };
53115     } catch (std::exception& e) {
53116       {
53117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53118       };
53119     } catch (Dali::DaliException e) {
53120       {
53121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53122       };
53123     } catch (...) {
53124       {
53125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53126       };
53127     }
53128   }
53129
53130   jresult = (void *)result;
53131   return jresult;
53132 }
53133
53134
53135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
53136   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53137
53138   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53139   {
53140     try {
53141       delete arg1;
53142     } catch (std::out_of_range& e) {
53143       {
53144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53145       };
53146     } catch (std::exception& e) {
53147       {
53148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53149       };
53150     } catch (Dali::DaliException e) {
53151       {
53152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53153       };
53154     } catch (...) {
53155       {
53156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53157       };
53158     }
53159   }
53160
53161 }
53162
53163
53164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
53165   void * jresult ;
53166   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53167
53168   {
53169     try {
53170       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
53171     } catch (std::out_of_range& e) {
53172       {
53173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53174       };
53175     } catch (std::exception& e) {
53176       {
53177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53178       };
53179     } catch (Dali::DaliException e) {
53180       {
53181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53182       };
53183     } catch (...) {
53184       {
53185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53186       };
53187     }
53188   }
53189
53190   jresult = (void *)result;
53191   return jresult;
53192 }
53193
53194
53195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
53196   void * jresult ;
53197   Dali::Radian arg1 ;
53198   Dali::Radian arg2 ;
53199   Dali::Radian *argp1 ;
53200   Dali::Radian *argp2 ;
53201   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53202
53203   argp1 = (Dali::Radian *)jarg1;
53204   if (!argp1) {
53205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53206     return 0;
53207   }
53208   arg1 = *argp1;
53209   argp2 = (Dali::Radian *)jarg2;
53210   if (!argp2) {
53211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53212     return 0;
53213   }
53214   arg2 = *argp2;
53215   {
53216     try {
53217       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
53218     } catch (std::out_of_range& e) {
53219       {
53220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53221       };
53222     } catch (std::exception& e) {
53223       {
53224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53225       };
53226     } catch (Dali::DaliException e) {
53227       {
53228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53229       };
53230     } catch (...) {
53231       {
53232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53233       };
53234     }
53235   }
53236
53237   jresult = (void *)result;
53238   return jresult;
53239 }
53240
53241
53242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
53243   void * jresult ;
53244   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
53245   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53246
53247   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53248   if (!arg1) {
53249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
53250     return 0;
53251   }
53252   {
53253     try {
53254       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
53255     } catch (std::out_of_range& e) {
53256       {
53257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53258       };
53259     } catch (std::exception& e) {
53260       {
53261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53262       };
53263     } catch (Dali::DaliException e) {
53264       {
53265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53266       };
53267     } catch (...) {
53268       {
53269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53270       };
53271     }
53272   }
53273
53274   jresult = (void *)result;
53275   return jresult;
53276 }
53277
53278
53279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
53280   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53281   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53282
53283   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53284   arg2 = (Dali::Radian *)jarg2;
53285   if (arg1) (arg1)->first = *arg2;
53286 }
53287
53288
53289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
53290   void * jresult ;
53291   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53292   Dali::Radian *result = 0 ;
53293
53294   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53295   result = (Dali::Radian *)& ((arg1)->first);
53296   jresult = (void *)result;
53297   return jresult;
53298 }
53299
53300
53301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
53302   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53303   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53304
53305   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53306   arg2 = (Dali::Radian *)jarg2;
53307   if (arg1) (arg1)->second = *arg2;
53308 }
53309
53310
53311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
53312   void * jresult ;
53313   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53314   Dali::Radian *result = 0 ;
53315
53316   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53317   result = (Dali::Radian *)& ((arg1)->second);
53318   jresult = (void *)result;
53319   return jresult;
53320 }
53321
53322
53323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
53324   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53325
53326   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53327   {
53328     try {
53329       delete arg1;
53330     } catch (std::out_of_range& e) {
53331       {
53332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53333       };
53334     } catch (std::exception& e) {
53335       {
53336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53337       };
53338     } catch (Dali::DaliException e) {
53339       {
53340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53341       };
53342     } catch (...) {
53343       {
53344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53345       };
53346     }
53347   }
53348
53349 }
53350
53351
53352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
53353   unsigned int jresult ;
53354   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53355   bool result;
53356
53357   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53358   {
53359     try {
53360       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);
53361     } catch (std::out_of_range& e) {
53362       {
53363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53364       };
53365     } catch (std::exception& e) {
53366       {
53367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53368       };
53369     } catch (Dali::DaliException e) {
53370       {
53371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53372       };
53373     } catch (...) {
53374       {
53375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53376       };
53377     }
53378   }
53379
53380   jresult = result;
53381   return jresult;
53382 }
53383
53384
53385 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53386   unsigned long jresult ;
53387   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53388   std::size_t result;
53389
53390   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53391   {
53392     try {
53393       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);
53394     } catch (std::out_of_range& e) {
53395       {
53396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53397       };
53398     } catch (std::exception& e) {
53399       {
53400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53401       };
53402     } catch (Dali::DaliException e) {
53403       {
53404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53405       };
53406     } catch (...) {
53407       {
53408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53409       };
53410     }
53411   }
53412
53413   jresult = (unsigned long)result;
53414   return jresult;
53415 }
53416
53417
53418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53419   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53420   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53421
53422   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53423   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53424   {
53425     try {
53426       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53427     } catch (std::out_of_range& e) {
53428       {
53429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53430       };
53431     } catch (std::exception& e) {
53432       {
53433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53434       };
53435     } catch (Dali::DaliException e) {
53436       {
53437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53438       };
53439     } catch (...) {
53440       {
53441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53442       };
53443     }
53444   }
53445
53446 }
53447
53448
53449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53450   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53451   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53452
53453   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53454   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53455   {
53456     try {
53457       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53458     } catch (std::out_of_range& e) {
53459       {
53460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53461       };
53462     } catch (std::exception& e) {
53463       {
53464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53465       };
53466     } catch (Dali::DaliException e) {
53467       {
53468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53469       };
53470     } catch (...) {
53471       {
53472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53473       };
53474     }
53475   }
53476
53477 }
53478
53479
53480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53481   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53482   Dali::Actor arg2 ;
53483   Dali::PanGesture *arg3 = 0 ;
53484   Dali::Actor *argp2 ;
53485
53486   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53487   argp2 = (Dali::Actor *)jarg2;
53488   if (!argp2) {
53489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53490     return ;
53491   }
53492   arg2 = *argp2;
53493   arg3 = (Dali::PanGesture *)jarg3;
53494   if (!arg3) {
53495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
53496     return ;
53497   }
53498   {
53499     try {
53500       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
53501     } catch (std::out_of_range& e) {
53502       {
53503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53504       };
53505     } catch (std::exception& e) {
53506       {
53507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53508       };
53509     } catch (Dali::DaliException e) {
53510       {
53511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53512       };
53513     } catch (...) {
53514       {
53515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53516       };
53517     }
53518   }
53519
53520 }
53521
53522
53523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
53524   void * jresult ;
53525   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
53526
53527   {
53528     try {
53529       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
53530     } catch (std::out_of_range& e) {
53531       {
53532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53533       };
53534     } catch (std::exception& e) {
53535       {
53536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53537       };
53538     } catch (Dali::DaliException e) {
53539       {
53540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53541       };
53542     } catch (...) {
53543       {
53544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53545       };
53546     }
53547   }
53548
53549   jresult = (void *)result;
53550   return jresult;
53551 }
53552
53553
53554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
53555   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53556
53557   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53558   {
53559     try {
53560       delete arg1;
53561     } catch (std::out_of_range& e) {
53562       {
53563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53564       };
53565     } catch (std::exception& e) {
53566       {
53567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53568       };
53569     } catch (Dali::DaliException e) {
53570       {
53571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53572       };
53573     } catch (...) {
53574       {
53575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53576       };
53577     }
53578   }
53579
53580 }
53581
53582
53583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
53584   unsigned int jresult ;
53585   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53586   bool result;
53587
53588   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53589   {
53590     try {
53591       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);
53592     } catch (std::out_of_range& e) {
53593       {
53594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53595       };
53596     } catch (std::exception& e) {
53597       {
53598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53599       };
53600     } catch (Dali::DaliException e) {
53601       {
53602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53603       };
53604     } catch (...) {
53605       {
53606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53607       };
53608     }
53609   }
53610
53611   jresult = result;
53612   return jresult;
53613 }
53614
53615
53616 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53617   unsigned long jresult ;
53618   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53619   std::size_t result;
53620
53621   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53622   {
53623     try {
53624       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);
53625     } catch (std::out_of_range& e) {
53626       {
53627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53628       };
53629     } catch (std::exception& e) {
53630       {
53631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53632       };
53633     } catch (Dali::DaliException e) {
53634       {
53635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53636       };
53637     } catch (...) {
53638       {
53639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53640       };
53641     }
53642   }
53643
53644   jresult = (unsigned long)result;
53645   return jresult;
53646 }
53647
53648
53649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53650   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53651   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53652
53653   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53654   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53655   {
53656     try {
53657       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53658     } catch (std::out_of_range& e) {
53659       {
53660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53661       };
53662     } catch (std::exception& e) {
53663       {
53664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53665       };
53666     } catch (Dali::DaliException e) {
53667       {
53668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53669       };
53670     } catch (...) {
53671       {
53672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53673       };
53674     }
53675   }
53676
53677 }
53678
53679
53680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53681   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53682   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53683
53684   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53685   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53686   {
53687     try {
53688       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53689     } catch (std::out_of_range& e) {
53690       {
53691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53692       };
53693     } catch (std::exception& e) {
53694       {
53695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53696       };
53697     } catch (Dali::DaliException e) {
53698       {
53699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53700       };
53701     } catch (...) {
53702       {
53703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53704       };
53705     }
53706   }
53707
53708 }
53709
53710
53711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53712   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53713   Dali::Actor arg2 ;
53714   Dali::PinchGesture *arg3 = 0 ;
53715   Dali::Actor *argp2 ;
53716
53717   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53718   argp2 = (Dali::Actor *)jarg2;
53719   if (!argp2) {
53720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53721     return ;
53722   }
53723   arg2 = *argp2;
53724   arg3 = (Dali::PinchGesture *)jarg3;
53725   if (!arg3) {
53726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
53727     return ;
53728   }
53729   {
53730     try {
53731       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
53732     } catch (std::out_of_range& e) {
53733       {
53734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53735       };
53736     } catch (std::exception& e) {
53737       {
53738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53739       };
53740     } catch (Dali::DaliException e) {
53741       {
53742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53743       };
53744     } catch (...) {
53745       {
53746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53747       };
53748     }
53749   }
53750
53751 }
53752
53753
53754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
53755   void * jresult ;
53756   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
53757
53758   {
53759     try {
53760       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
53761     } catch (std::out_of_range& e) {
53762       {
53763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53764       };
53765     } catch (std::exception& e) {
53766       {
53767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53768       };
53769     } catch (Dali::DaliException e) {
53770       {
53771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53772       };
53773     } catch (...) {
53774       {
53775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53776       };
53777     }
53778   }
53779
53780   jresult = (void *)result;
53781   return jresult;
53782 }
53783
53784
53785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
53786   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53787
53788   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53789   {
53790     try {
53791       delete arg1;
53792     } catch (std::out_of_range& e) {
53793       {
53794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53795       };
53796     } catch (std::exception& e) {
53797       {
53798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53799       };
53800     } catch (Dali::DaliException e) {
53801       {
53802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53803       };
53804     } catch (...) {
53805       {
53806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53807       };
53808     }
53809   }
53810
53811 }
53812
53813
53814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
53815   unsigned int jresult ;
53816   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53817   bool result;
53818
53819   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53820   {
53821     try {
53822       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);
53823     } catch (std::out_of_range& e) {
53824       {
53825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53826       };
53827     } catch (std::exception& e) {
53828       {
53829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53830       };
53831     } catch (Dali::DaliException e) {
53832       {
53833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53834       };
53835     } catch (...) {
53836       {
53837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53838       };
53839     }
53840   }
53841
53842   jresult = result;
53843   return jresult;
53844 }
53845
53846
53847 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53848   unsigned long jresult ;
53849   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53850   std::size_t result;
53851
53852   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53853   {
53854     try {
53855       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);
53856     } catch (std::out_of_range& e) {
53857       {
53858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53859       };
53860     } catch (std::exception& e) {
53861       {
53862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53863       };
53864     } catch (Dali::DaliException e) {
53865       {
53866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53867       };
53868     } catch (...) {
53869       {
53870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53871       };
53872     }
53873   }
53874
53875   jresult = (unsigned long)result;
53876   return jresult;
53877 }
53878
53879
53880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53881   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53882   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
53883
53884   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53885   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
53886   {
53887     try {
53888       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53889     } catch (std::out_of_range& e) {
53890       {
53891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53892       };
53893     } catch (std::exception& e) {
53894       {
53895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53896       };
53897     } catch (Dali::DaliException e) {
53898       {
53899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53900       };
53901     } catch (...) {
53902       {
53903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53904       };
53905     }
53906   }
53907
53908 }
53909
53910
53911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53912   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53913   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
53914
53915   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53916   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
53917   {
53918     try {
53919       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53920     } catch (std::out_of_range& e) {
53921       {
53922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53923       };
53924     } catch (std::exception& e) {
53925       {
53926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53927       };
53928     } catch (Dali::DaliException e) {
53929       {
53930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53931       };
53932     } catch (...) {
53933       {
53934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53935       };
53936     }
53937   }
53938
53939 }
53940
53941
53942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53943   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53944   Dali::Actor arg2 ;
53945   Dali::TapGesture *arg3 = 0 ;
53946   Dali::Actor *argp2 ;
53947
53948   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53949   argp2 = (Dali::Actor *)jarg2;
53950   if (!argp2) {
53951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53952     return ;
53953   }
53954   arg2 = *argp2;
53955   arg3 = (Dali::TapGesture *)jarg3;
53956   if (!arg3) {
53957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
53958     return ;
53959   }
53960   {
53961     try {
53962       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
53963     } catch (std::out_of_range& e) {
53964       {
53965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53966       };
53967     } catch (std::exception& e) {
53968       {
53969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53970       };
53971     } catch (Dali::DaliException e) {
53972       {
53973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53974       };
53975     } catch (...) {
53976       {
53977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53978       };
53979     }
53980   }
53981
53982 }
53983
53984
53985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
53986   void * jresult ;
53987   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
53988
53989   {
53990     try {
53991       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
53992     } catch (std::out_of_range& e) {
53993       {
53994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53995       };
53996     } catch (std::exception& e) {
53997       {
53998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53999       };
54000     } catch (Dali::DaliException e) {
54001       {
54002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54003       };
54004     } catch (...) {
54005       {
54006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54007       };
54008     }
54009   }
54010
54011   jresult = (void *)result;
54012   return jresult;
54013 }
54014
54015
54016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
54017   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54018
54019   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54020   {
54021     try {
54022       delete arg1;
54023     } catch (std::out_of_range& e) {
54024       {
54025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54026       };
54027     } catch (std::exception& e) {
54028       {
54029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54030       };
54031     } catch (Dali::DaliException e) {
54032       {
54033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54034       };
54035     } catch (...) {
54036       {
54037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54038       };
54039     }
54040   }
54041
54042 }
54043
54044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
54045   unsigned int jresult ;
54046   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54047   bool result = false;
54048
54049   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54050   {
54051     try {
54052       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);
54053     } catch (std::out_of_range& e) {
54054       {
54055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54056       };
54057     } catch (std::exception& e) {
54058       {
54059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54060       };
54061     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54062   }
54063   jresult = result;
54064   return jresult;
54065 }
54066
54067 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
54068   unsigned long jresult ;
54069   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54070   std::size_t result = 0;
54071
54072   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54073   {
54074     try {
54075       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);
54076     } catch (std::out_of_range& e) {
54077       {
54078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54079       };
54080     } catch (std::exception& e) {
54081       {
54082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54083       };
54084     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54085   }
54086   jresult = (unsigned long)result;
54087   return jresult;
54088 }
54089
54090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
54091   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54092   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54093
54094   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54095   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54096   {
54097     try {
54098       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
54099     } catch (std::out_of_range& e) {
54100       {
54101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54102       };
54103     } catch (std::exception& e) {
54104       {
54105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54106       };
54107     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54108   }
54109 }
54110
54111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
54112   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54113   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54114
54115   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54116   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54117   {
54118     try {
54119       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
54120     } catch (std::out_of_range& e) {
54121       {
54122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54123       };
54124     } catch (std::exception& e) {
54125       {
54126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54127       };
54128     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54129   }
54130 }
54131
54132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
54133   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54134   Dali::Actor arg2 ;
54135   //bool arg3 ;
54136   Dali::LayoutDirection::Type arg4 ;
54137   Dali::Actor *argp2 ;
54138
54139   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54140   argp2 = (Dali::Actor *)jarg2;
54141   if (!argp2) {
54142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54143     return ;
54144   }
54145   arg2 = *argp2;
54146   //arg3 = jarg3 ? true : false;
54147   arg4 = (Dali::LayoutDirection::Type)jarg4;
54148   {
54149     try {
54150       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
54151     } catch (std::out_of_range& e) {
54152       {
54153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54154       };
54155     } catch (std::exception& e) {
54156       {
54157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54158       };
54159     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54160   }
54161 }
54162
54163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
54164   void * jresult ;
54165   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
54166
54167   {
54168     try {
54169       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
54170     } catch (std::out_of_range& e) {
54171       {
54172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54173       };
54174     } catch (std::exception& e) {
54175       {
54176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54177       };
54178     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54179   }
54180   jresult = (void *)result;
54181   return jresult;
54182 }
54183
54184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
54185   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54186
54187   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54188   {
54189     try {
54190       delete arg1;
54191     } catch (std::out_of_range& e) {
54192       {
54193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54194       };
54195     } catch (std::exception& e) {
54196       {
54197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54198       };
54199     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54200   }
54201 }
54202
54203 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
54204   unsigned int jresult ;
54205   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54206   bool result;
54207
54208   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54209   {
54210     try {
54211       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);
54212     } catch (std::out_of_range& e) {
54213       {
54214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54215       };
54216     } catch (std::exception& e) {
54217       {
54218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54219       };
54220     } catch (Dali::DaliException e) {
54221       {
54222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54223       };
54224     } catch (...) {
54225       {
54226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54227       };
54228     }
54229   }
54230
54231   jresult = result;
54232   return jresult;
54233 }
54234
54235
54236 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
54237   unsigned long jresult ;
54238   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54239   std::size_t result;
54240
54241   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54242   {
54243     try {
54244       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);
54245     } catch (std::out_of_range& e) {
54246       {
54247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54248       };
54249     } catch (std::exception& e) {
54250       {
54251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54252       };
54253     } catch (Dali::DaliException e) {
54254       {
54255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54256       };
54257     } catch (...) {
54258       {
54259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54260       };
54261     }
54262   }
54263
54264   jresult = (unsigned long)result;
54265   return jresult;
54266 }
54267
54268
54269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
54270   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54271   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54272
54273   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54274   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54275   {
54276     try {
54277       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
54278     } catch (std::out_of_range& e) {
54279       {
54280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54281       };
54282     } catch (std::exception& e) {
54283       {
54284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54285       };
54286     } catch (Dali::DaliException e) {
54287       {
54288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54289       };
54290     } catch (...) {
54291       {
54292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54293       };
54294     }
54295   }
54296
54297 }
54298
54299
54300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54301   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54302   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54303
54304   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54305   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54306   {
54307     try {
54308       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
54309     } catch (std::out_of_range& e) {
54310       {
54311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54312       };
54313     } catch (std::exception& e) {
54314       {
54315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54316       };
54317     } catch (Dali::DaliException e) {
54318       {
54319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54320       };
54321     } catch (...) {
54322       {
54323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54324       };
54325     }
54326   }
54327
54328 }
54329
54330
54331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
54332   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54333   Dali::Actor arg2 ;
54334   bool arg3 ;
54335   Dali::DevelActor::VisibilityChange::Type arg4 ;
54336   Dali::Actor *argp2 ;
54337
54338   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54339   argp2 = (Dali::Actor *)jarg2;
54340   if (!argp2) {
54341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54342     return ;
54343   }
54344   arg2 = *argp2;
54345   arg3 = jarg3 ? true : false;
54346   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
54347   {
54348     try {
54349       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54350     } catch (std::out_of_range& e) {
54351       {
54352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54353       };
54354     } catch (std::exception& e) {
54355       {
54356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54357       };
54358     } catch (Dali::DaliException e) {
54359       {
54360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54361       };
54362     } catch (...) {
54363       {
54364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54365       };
54366     }
54367   }
54368
54369 }
54370
54371
54372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
54373   void * jresult ;
54374   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
54375
54376   {
54377     try {
54378       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
54379     } catch (std::out_of_range& e) {
54380       {
54381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54382       };
54383     } catch (std::exception& e) {
54384       {
54385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54386       };
54387     } catch (Dali::DaliException e) {
54388       {
54389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54390       };
54391     } catch (...) {
54392       {
54393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54394       };
54395     }
54396   }
54397
54398   jresult = (void *)result;
54399   return jresult;
54400 }
54401
54402
54403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
54404   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54405
54406   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54407   {
54408     try {
54409       delete arg1;
54410     } catch (std::out_of_range& e) {
54411       {
54412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54413       };
54414     } catch (std::exception& e) {
54415       {
54416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54417       };
54418     } catch (Dali::DaliException e) {
54419       {
54420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54421       };
54422     } catch (...) {
54423       {
54424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54425       };
54426     }
54427   }
54428
54429 }
54430
54431
54432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
54433   void * jresult ;
54434   Dali::Timer *result = 0 ;
54435
54436   {
54437     try {
54438       result = (Dali::Timer *)new Dali::Timer();
54439     } catch (std::out_of_range& e) {
54440       {
54441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54442       };
54443     } catch (std::exception& e) {
54444       {
54445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54446       };
54447     } catch (Dali::DaliException e) {
54448       {
54449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54450       };
54451     } catch (...) {
54452       {
54453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54454       };
54455     }
54456   }
54457
54458   jresult = (void *)result;
54459   return jresult;
54460 }
54461
54462
54463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
54464   void * jresult ;
54465   unsigned int arg1 ;
54466   Dali::Timer result;
54467
54468   arg1 = (unsigned int)jarg1;
54469   {
54470     try {
54471       result = Dali::Timer::New(arg1);
54472     } catch (std::out_of_range& e) {
54473       {
54474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54475       };
54476     } catch (std::exception& e) {
54477       {
54478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54479       };
54480     } catch (Dali::DaliException e) {
54481       {
54482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54483       };
54484     } catch (...) {
54485       {
54486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54487       };
54488     }
54489   }
54490
54491   jresult = new Dali::Timer((const Dali::Timer &)result);
54492   return jresult;
54493 }
54494
54495
54496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
54497   void * jresult ;
54498   Dali::Timer *arg1 = 0 ;
54499   Dali::Timer *result = 0 ;
54500
54501   arg1 = (Dali::Timer *)jarg1;
54502   if (!arg1) {
54503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54504     return 0;
54505   }
54506   {
54507     try {
54508       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
54509     } catch (std::out_of_range& e) {
54510       {
54511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54512       };
54513     } catch (std::exception& e) {
54514       {
54515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54516       };
54517     } catch (Dali::DaliException e) {
54518       {
54519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54520       };
54521     } catch (...) {
54522       {
54523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54524       };
54525     }
54526   }
54527
54528   jresult = (void *)result;
54529   return jresult;
54530 }
54531
54532
54533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
54534   void * jresult ;
54535   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54536   Dali::Timer *arg2 = 0 ;
54537   Dali::Timer *result = 0 ;
54538
54539   arg1 = (Dali::Timer *)jarg1;
54540   arg2 = (Dali::Timer *)jarg2;
54541   if (!arg2) {
54542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54543     return 0;
54544   }
54545   {
54546     try {
54547       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
54548     } catch (std::out_of_range& e) {
54549       {
54550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54551       };
54552     } catch (std::exception& e) {
54553       {
54554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54555       };
54556     } catch (Dali::DaliException e) {
54557       {
54558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54559       };
54560     } catch (...) {
54561       {
54562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54563       };
54564     }
54565   }
54566
54567   jresult = (void *)result;
54568   return jresult;
54569 }
54570
54571
54572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
54573   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54574
54575   arg1 = (Dali::Timer *)jarg1;
54576   {
54577     try {
54578       delete arg1;
54579     } catch (std::out_of_range& e) {
54580       {
54581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54582       };
54583     } catch (std::exception& e) {
54584       {
54585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54586       };
54587     } catch (Dali::DaliException e) {
54588       {
54589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54590       };
54591     } catch (...) {
54592       {
54593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54594       };
54595     }
54596   }
54597
54598 }
54599
54600
54601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
54602   void * jresult ;
54603   Dali::BaseHandle arg1 ;
54604   Dali::BaseHandle *argp1 ;
54605   Dali::Timer result;
54606
54607   argp1 = (Dali::BaseHandle *)jarg1;
54608   if (!argp1) {
54609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54610     return 0;
54611   }
54612   arg1 = *argp1;
54613   {
54614     try {
54615       result = Dali::Timer::DownCast(arg1);
54616     } catch (std::out_of_range& e) {
54617       {
54618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54619       };
54620     } catch (std::exception& e) {
54621       {
54622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54623       };
54624     } catch (Dali::DaliException e) {
54625       {
54626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54627       };
54628     } catch (...) {
54629       {
54630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54631       };
54632     }
54633   }
54634
54635   jresult = new Dali::Timer((const Dali::Timer &)result);
54636   return jresult;
54637 }
54638
54639
54640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
54641   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54642
54643   arg1 = (Dali::Timer *)jarg1;
54644   {
54645     try {
54646       (arg1)->Start();
54647     } catch (std::out_of_range& e) {
54648       {
54649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54650       };
54651     } catch (std::exception& e) {
54652       {
54653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54654       };
54655     } catch (Dali::DaliException e) {
54656       {
54657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54658       };
54659     } catch (...) {
54660       {
54661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54662       };
54663     }
54664   }
54665
54666 }
54667
54668
54669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
54670   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54671
54672   arg1 = (Dali::Timer *)jarg1;
54673   {
54674     try {
54675       (arg1)->Stop();
54676     } catch (std::out_of_range& e) {
54677       {
54678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54679       };
54680     } catch (std::exception& e) {
54681       {
54682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54683       };
54684     } catch (Dali::DaliException e) {
54685       {
54686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54687       };
54688     } catch (...) {
54689       {
54690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54691       };
54692     }
54693   }
54694
54695 }
54696
54697
54698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
54699   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54700   unsigned int arg2 ;
54701
54702   arg1 = (Dali::Timer *)jarg1;
54703   arg2 = (unsigned int)jarg2;
54704   {
54705     try {
54706       (arg1)->SetInterval(arg2);
54707     } catch (std::out_of_range& e) {
54708       {
54709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54710       };
54711     } catch (std::exception& e) {
54712       {
54713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54714       };
54715     } catch (Dali::DaliException e) {
54716       {
54717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54718       };
54719     } catch (...) {
54720       {
54721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54722       };
54723     }
54724   }
54725
54726 }
54727
54728
54729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
54730   unsigned int jresult ;
54731   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54732   unsigned int result;
54733
54734   arg1 = (Dali::Timer *)jarg1;
54735   {
54736     try {
54737       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
54738     } catch (std::out_of_range& e) {
54739       {
54740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54741       };
54742     } catch (std::exception& e) {
54743       {
54744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54745       };
54746     } catch (Dali::DaliException e) {
54747       {
54748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54749       };
54750     } catch (...) {
54751       {
54752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54753       };
54754     }
54755   }
54756
54757   jresult = result;
54758   return jresult;
54759 }
54760
54761
54762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
54763   unsigned int jresult ;
54764   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54765   bool result;
54766
54767   arg1 = (Dali::Timer *)jarg1;
54768   {
54769     try {
54770       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
54771     } catch (std::out_of_range& e) {
54772       {
54773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54774       };
54775     } catch (std::exception& e) {
54776       {
54777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54778       };
54779     } catch (Dali::DaliException e) {
54780       {
54781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54782       };
54783     } catch (...) {
54784       {
54785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54786       };
54787     }
54788   }
54789
54790   jresult = result;
54791   return jresult;
54792 }
54793
54794
54795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
54796   void * jresult ;
54797   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54798   Dali::Timer::TimerSignalType *result = 0 ;
54799
54800   arg1 = (Dali::Timer *)jarg1;
54801   {
54802     try {
54803       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
54804     } catch (std::out_of_range& e) {
54805       {
54806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54807       };
54808     } catch (std::exception& e) {
54809       {
54810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54811       };
54812     } catch (Dali::DaliException e) {
54813       {
54814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54815       };
54816     } catch (...) {
54817       {
54818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54819       };
54820     }
54821   }
54822
54823   jresult = (void *)result;
54824   return jresult;
54825 }
54826
54827
54828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
54829   unsigned int jresult ;
54830   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54831   bool result;
54832
54833   arg1 = (Dali::Signal< bool () > *)jarg1;
54834   {
54835     try {
54836       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
54837     } catch (std::out_of_range& e) {
54838       {
54839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54840       };
54841     } catch (std::exception& e) {
54842       {
54843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54844       };
54845     } catch (Dali::DaliException e) {
54846       {
54847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54848       };
54849     } catch (...) {
54850       {
54851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54852       };
54853     }
54854   }
54855
54856   jresult = result;
54857   return jresult;
54858 }
54859
54860
54861 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
54862   unsigned long jresult ;
54863   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54864   std::size_t result;
54865
54866   arg1 = (Dali::Signal< bool () > *)jarg1;
54867   {
54868     try {
54869       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
54870     } catch (std::out_of_range& e) {
54871       {
54872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54873       };
54874     } catch (std::exception& e) {
54875       {
54876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54877       };
54878     } catch (Dali::DaliException e) {
54879       {
54880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54881       };
54882     } catch (...) {
54883       {
54884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54885       };
54886     }
54887   }
54888
54889   jresult = (unsigned long)result;
54890   return jresult;
54891 }
54892
54893
54894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
54895   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54896   bool (*arg2)() = (bool (*)()) 0 ;
54897
54898   arg1 = (Dali::Signal< bool () > *)jarg1;
54899   arg2 = (bool (*)())jarg2;
54900   {
54901     try {
54902       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
54903     } catch (std::out_of_range& e) {
54904       {
54905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54906       };
54907     } catch (std::exception& e) {
54908       {
54909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54910       };
54911     } catch (Dali::DaliException e) {
54912       {
54913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54914       };
54915     } catch (...) {
54916       {
54917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54918       };
54919     }
54920   }
54921
54922 }
54923
54924
54925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
54926   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54927   bool (*arg2)() = (bool (*)()) 0 ;
54928
54929   arg1 = (Dali::Signal< bool () > *)jarg1;
54930   arg2 = (bool (*)())jarg2;
54931   {
54932     try {
54933       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
54934     } catch (std::out_of_range& e) {
54935       {
54936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54937       };
54938     } catch (std::exception& e) {
54939       {
54940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54941       };
54942     } catch (Dali::DaliException e) {
54943       {
54944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54945       };
54946     } catch (...) {
54947       {
54948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54949       };
54950     }
54951   }
54952
54953 }
54954
54955
54956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
54957   unsigned int jresult ;
54958   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54959   bool result;
54960
54961   arg1 = (Dali::Signal< bool () > *)jarg1;
54962   {
54963     try {
54964       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
54965     } catch (std::out_of_range& e) {
54966       {
54967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54968       };
54969     } catch (std::exception& e) {
54970       {
54971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54972       };
54973     } catch (Dali::DaliException e) {
54974       {
54975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54976       };
54977     } catch (...) {
54978       {
54979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54980       };
54981     }
54982   }
54983
54984   jresult = result;
54985   return jresult;
54986 }
54987
54988
54989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
54990   void * jresult ;
54991   Dali::Signal< bool () > *result = 0 ;
54992
54993   {
54994     try {
54995       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
54996     } catch (std::out_of_range& e) {
54997       {
54998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54999       };
55000     } catch (std::exception& e) {
55001       {
55002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55003       };
55004     } catch (Dali::DaliException e) {
55005       {
55006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55007       };
55008     } catch (...) {
55009       {
55010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55011       };
55012     }
55013   }
55014
55015   jresult = (void *)result;
55016   return jresult;
55017 }
55018
55019
55020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55021   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55022
55023   arg1 = (Dali::Signal< bool () > *)jarg1;
55024   {
55025     try {
55026       delete arg1;
55027     } catch (std::out_of_range& e) {
55028       {
55029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55030       };
55031     } catch (std::exception& e) {
55032       {
55033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55034       };
55035     } catch (Dali::DaliException e) {
55036       {
55037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55038       };
55039     } catch (...) {
55040       {
55041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55042       };
55043     }
55044   }
55045
55046 }
55047
55048
55049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55050   int jresult ;
55051   int result;
55052
55053   {
55054     try {
55055       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55056     } catch (std::out_of_range& e) {
55057       {
55058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55059       };
55060     } catch (std::exception& e) {
55061       {
55062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55063       };
55064     } catch (Dali::DaliException e) {
55065       {
55066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55067       };
55068     } catch (...) {
55069       {
55070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55071       };
55072     }
55073   }
55074
55075   jresult = (int)result;
55076   return jresult;
55077 }
55078
55079
55080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55081   int jresult ;
55082   int result;
55083
55084   {
55085     try {
55086       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55087     } catch (std::out_of_range& e) {
55088       {
55089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55090       };
55091     } catch (std::exception& e) {
55092       {
55093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55094       };
55095     } catch (Dali::DaliException e) {
55096       {
55097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55098       };
55099     } catch (...) {
55100       {
55101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55102       };
55103     }
55104   }
55105
55106   jresult = (int)result;
55107   return jresult;
55108 }
55109
55110
55111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55112   int jresult ;
55113   int result;
55114
55115   {
55116     try {
55117       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55118     } catch (std::out_of_range& e) {
55119       {
55120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55121       };
55122     } catch (std::exception& e) {
55123       {
55124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55125       };
55126     } catch (Dali::DaliException e) {
55127       {
55128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55129       };
55130     } catch (...) {
55131       {
55132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55133       };
55134     }
55135   }
55136
55137   jresult = (int)result;
55138   return jresult;
55139 }
55140
55141
55142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55143   int jresult ;
55144   int result;
55145
55146   {
55147     try {
55148       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55149     } catch (std::out_of_range& e) {
55150       {
55151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55152       };
55153     } catch (std::exception& e) {
55154       {
55155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55156       };
55157     } catch (Dali::DaliException e) {
55158       {
55159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55160       };
55161     } catch (...) {
55162       {
55163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55164       };
55165     }
55166   }
55167
55168   jresult = (int)result;
55169   return jresult;
55170 }
55171
55172
55173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55174   int jresult ;
55175   int result;
55176
55177   {
55178     try {
55179       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55180     } catch (std::out_of_range& e) {
55181       {
55182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55183       };
55184     } catch (std::exception& e) {
55185       {
55186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55187       };
55188     } catch (Dali::DaliException e) {
55189       {
55190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55191       };
55192     } catch (...) {
55193       {
55194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55195       };
55196     }
55197   }
55198
55199   jresult = (int)result;
55200   return jresult;
55201 }
55202
55203
55204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55205   int jresult ;
55206   int result;
55207
55208   {
55209     try {
55210       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
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 = (int)result;
55231   return jresult;
55232 }
55233
55234
55235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55236   int jresult ;
55237   int result;
55238
55239   {
55240     try {
55241       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
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 = (int)result;
55262   return jresult;
55263 }
55264
55265
55266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55267   int jresult ;
55268   int result;
55269
55270   {
55271     try {
55272       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55273     } catch (std::out_of_range& e) {
55274       {
55275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55276       };
55277     } catch (std::exception& e) {
55278       {
55279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55280       };
55281     } catch (Dali::DaliException e) {
55282       {
55283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55284       };
55285     } catch (...) {
55286       {
55287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55288       };
55289     }
55290   }
55291
55292   jresult = (int)result;
55293   return jresult;
55294 }
55295
55296
55297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55298   int jresult ;
55299   int result;
55300
55301   {
55302     try {
55303       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55304     } catch (std::out_of_range& e) {
55305       {
55306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55307       };
55308     } catch (std::exception& e) {
55309       {
55310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55311       };
55312     } catch (Dali::DaliException e) {
55313       {
55314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55315       };
55316     } catch (...) {
55317       {
55318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55319       };
55320     }
55321   }
55322
55323   jresult = (int)result;
55324   return jresult;
55325 }
55326
55327
55328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
55329   int jresult ;
55330   int result;
55331
55332   {
55333     try {
55334       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55335     } catch (std::out_of_range& e) {
55336       {
55337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55338       };
55339     } catch (std::exception& e) {
55340       {
55341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55342       };
55343     } catch (Dali::DaliException e) {
55344       {
55345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55346       };
55347     } catch (...) {
55348       {
55349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55350       };
55351     }
55352   }
55353
55354   jresult = (int)result;
55355   return jresult;
55356 }
55357
55358
55359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
55360   int jresult ;
55361   int result;
55362
55363   {
55364     try {
55365       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
55366     } catch (std::out_of_range& e) {
55367       {
55368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55369       };
55370     } catch (std::exception& e) {
55371       {
55372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55373       };
55374     } catch (Dali::DaliException e) {
55375       {
55376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55377       };
55378     } catch (...) {
55379       {
55380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55381       };
55382     }
55383   }
55384
55385   jresult = (int)result;
55386   return jresult;
55387 }
55388
55389
55390 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
55391   int jresult ;
55392   int result;
55393
55394   {
55395     try {
55396       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
55397     } catch (std::out_of_range& e) {
55398       {
55399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55400       };
55401     } catch (std::exception& e) {
55402       {
55403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55404       };
55405     } catch (Dali::DaliException e) {
55406       {
55407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55408       };
55409     } catch (...) {
55410       {
55411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55412       };
55413     }
55414   }
55415
55416   jresult = (int)result;
55417   return jresult;
55418 }
55419
55420
55421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
55422   int jresult ;
55423   int result;
55424
55425   {
55426     try {
55427       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
55428     } catch (std::out_of_range& e) {
55429       {
55430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55431       };
55432     } catch (std::exception& e) {
55433       {
55434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55435       };
55436     } catch (Dali::DaliException e) {
55437       {
55438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55439       };
55440     } catch (...) {
55441       {
55442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55443       };
55444     }
55445   }
55446
55447   jresult = (int)result;
55448   return jresult;
55449 }
55450
55451
55452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
55453   int jresult ;
55454   int result;
55455
55456   {
55457     try {
55458       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
55459     } catch (std::out_of_range& e) {
55460       {
55461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55462       };
55463     } catch (std::exception& e) {
55464       {
55465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55466       };
55467     } catch (Dali::DaliException e) {
55468       {
55469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55470       };
55471     } catch (...) {
55472       {
55473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55474       };
55475     }
55476   }
55477
55478   jresult = (int)result;
55479   return jresult;
55480 }
55481
55482
55483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
55484   int jresult ;
55485   int result;
55486
55487   {
55488     try {
55489       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
55490     } catch (std::out_of_range& e) {
55491       {
55492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55493       };
55494     } catch (std::exception& e) {
55495       {
55496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55497       };
55498     } catch (Dali::DaliException e) {
55499       {
55500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55501       };
55502     } catch (...) {
55503       {
55504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55505       };
55506     }
55507   }
55508
55509   jresult = (int)result;
55510   return jresult;
55511 }
55512
55513
55514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
55515   int jresult ;
55516   int result;
55517
55518   {
55519     try {
55520       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
55521     } catch (std::out_of_range& e) {
55522       {
55523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55524       };
55525     } catch (std::exception& e) {
55526       {
55527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55528       };
55529     } catch (Dali::DaliException e) {
55530       {
55531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55532       };
55533     } catch (...) {
55534       {
55535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55536       };
55537     }
55538   }
55539
55540   jresult = (int)result;
55541   return jresult;
55542 }
55543
55544
55545 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
55546   int jresult ;
55547   int result;
55548
55549   {
55550     try {
55551       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
55552     } catch (std::out_of_range& e) {
55553       {
55554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55555       };
55556     } catch (std::exception& e) {
55557       {
55558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55559       };
55560     } catch (Dali::DaliException e) {
55561       {
55562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55563       };
55564     } catch (...) {
55565       {
55566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55567       };
55568     }
55569   }
55570
55571   jresult = (int)result;
55572   return jresult;
55573 }
55574
55575
55576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
55577   int jresult ;
55578   int result;
55579
55580   {
55581     try {
55582       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
55583     } catch (std::out_of_range& e) {
55584       {
55585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55586       };
55587     } catch (std::exception& e) {
55588       {
55589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55590       };
55591     } catch (Dali::DaliException e) {
55592       {
55593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55594       };
55595     } catch (...) {
55596       {
55597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55598       };
55599     }
55600   }
55601
55602   jresult = (int)result;
55603   return jresult;
55604 }
55605
55606
55607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
55608   int jresult ;
55609   int result;
55610
55611   {
55612     try {
55613       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
55614     } catch (std::out_of_range& e) {
55615       {
55616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55617       };
55618     } catch (std::exception& e) {
55619       {
55620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55621       };
55622     } catch (Dali::DaliException e) {
55623       {
55624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55625       };
55626     } catch (...) {
55627       {
55628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55629       };
55630     }
55631   }
55632
55633   jresult = (int)result;
55634   return jresult;
55635 }
55636
55637
55638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
55639   int jresult ;
55640   int result;
55641
55642   {
55643     try {
55644       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
55645     } catch (std::out_of_range& e) {
55646       {
55647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55648       };
55649     } catch (std::exception& e) {
55650       {
55651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55652       };
55653     } catch (Dali::DaliException e) {
55654       {
55655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55656       };
55657     } catch (...) {
55658       {
55659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55660       };
55661     }
55662   }
55663
55664   jresult = (int)result;
55665   return jresult;
55666 }
55667
55668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
55669   int jresult ;
55670   int result;
55671
55672   {
55673     try {
55674       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
55675     } catch (std::out_of_range& e) {
55676       {
55677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55678       };
55679     } catch (std::exception& e) {
55680       {
55681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55682       };
55683     } catch (Dali::DaliException e) {
55684       {
55685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55686       };
55687     } catch (...) {
55688       {
55689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55690       };
55691     }
55692   }
55693
55694   jresult = (int)result;
55695   return jresult;
55696 }
55697
55698
55699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
55700   int jresult ;
55701   int result;
55702   {
55703     try
55704     {
55705       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
55706     } catch (std::out_of_range& e) {
55707       {
55708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55709       };
55710     } catch (std::exception& e) {
55711       {
55712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55713       };
55714     } catch (Dali::DaliException e) {
55715       {
55716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55717       };
55718     } catch (...) {
55719       {
55720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55721       };
55722     }
55723   }
55724
55725   jresult = (int)result;
55726   return jresult;
55727 }
55728
55729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
55730   int jresult ;
55731   int result;
55732   {
55733     try
55734     {
55735       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
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 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
55760   int jresult ;
55761   int result;
55762   {
55763     try
55764     {
55765       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
55766     } catch (std::out_of_range& e) {
55767       {
55768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55769       };
55770     } catch (std::exception& e) {
55771       {
55772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55773       };
55774     } catch (Dali::DaliException e) {
55775       {
55776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55777       };
55778     } catch (...) {
55779       {
55780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55781       };
55782     }
55783   }
55784
55785   jresult = (int)result;
55786   return jresult;
55787 }
55788
55789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
55790   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
55791 }
55792
55793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
55794   int jresult ;
55795   int result;
55796   {
55797     try
55798     {
55799       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
55800     } catch (std::out_of_range& e) {
55801       {
55802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55803       };
55804     } catch (std::exception& e) {
55805       {
55806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55807       };
55808     } catch (Dali::DaliException e) {
55809       {
55810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55811       };
55812     } catch (...) {
55813       {
55814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55815       };
55816     }
55817   }
55818
55819   jresult = (int)result;
55820   return jresult;
55821 }
55822
55823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
55824   int jresult ;
55825   int result;
55826   {
55827     try
55828     {
55829       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
55830     } catch (std::out_of_range& e) {
55831       {
55832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55833       };
55834     } catch (std::exception& e) {
55835       {
55836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55837       };
55838     } catch (Dali::DaliException e) {
55839       {
55840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55841       };
55842     } catch (...) {
55843       {
55844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55845       };
55846     }
55847   }
55848
55849   jresult = (int)result;
55850   return jresult;
55851 }
55852
55853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
55854   int jresult ;
55855   int result;
55856
55857   {
55858     try {
55859       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
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_SAMPLING_MODE_get() {
55885   int jresult ;
55886   int result;
55887
55888   {
55889     try {
55890       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
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_RELEASE_POLICY_get() {
55915   int jresult ;
55916   int result;
55917   {
55918     try
55919     {
55920       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
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 (...) {
55930       {
55931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55932       };
55933     }
55934   }
55935   jresult = (int)result;
55936   return jresult;
55937 }
55938
55939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
55940   int jresult ;
55941   int result;
55942   {
55943     try
55944     {
55945       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
55946     } catch (std::out_of_range& e) {
55947       {
55948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55949       };
55950     } catch (std::exception& e) {
55951       {
55952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55953       };
55954     } catch (...) {
55955       {
55956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55957       };
55958     }
55959   }
55960   jresult = (int)result;
55961   return jresult;
55962 }
55963
55964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
55965   int jresult ;
55966   int result;
55967   {
55968     try
55969     {
55970       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
55971     } catch (std::out_of_range& e) {
55972       {
55973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55974       };
55975     } catch (std::exception& e) {
55976       {
55977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55978       };
55979     } catch (...) {
55980       {
55981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55982       };
55983     }
55984   }
55985   jresult = (int)result;
55986   return jresult;
55987 }
55988
55989
55990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
55991   int jresult ;
55992   int result;
55993   {
55994     try
55995     {
55996       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
55997     } catch (std::out_of_range& e) {
55998       {
55999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56000       };
56001     } catch (std::exception& e) {
56002       {
56003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56004       };
56005     } catch (...) {
56006       {
56007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56008       };
56009     }
56010   }
56011   jresult = (int)result;
56012   return jresult;
56013 }
56014
56015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
56016   int jresult ;
56017   int result;
56018   {
56019     try
56020     {
56021       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
56022     } catch (std::out_of_range& e) {
56023       {
56024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56025       };
56026     } catch (std::exception& e) {
56027       {
56028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56029       };
56030     } catch (...) {
56031       {
56032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56033       };
56034     }
56035   }
56036   jresult = (int)result;
56037   return jresult;
56038 }
56039
56040
56041
56042 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56043   int jresult ;
56044   int result;
56045
56046   {
56047     try {
56048       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56049     } catch (std::out_of_range& e) {
56050       {
56051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56052       };
56053     } catch (std::exception& e) {
56054       {
56055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56056       };
56057     } catch (Dali::DaliException e) {
56058       {
56059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56060       };
56061     } catch (...) {
56062       {
56063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56064       };
56065     }
56066   }
56067
56068   jresult = (int)result;
56069   return jresult;
56070 }
56071
56072
56073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56074   int jresult ;
56075   int result;
56076
56077   {
56078     try {
56079       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56080     } catch (std::out_of_range& e) {
56081       {
56082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56083       };
56084     } catch (std::exception& e) {
56085       {
56086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56087       };
56088     } catch (Dali::DaliException e) {
56089       {
56090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56091       };
56092     } catch (...) {
56093       {
56094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56095       };
56096     }
56097   }
56098
56099   jresult = (int)result;
56100   return jresult;
56101 }
56102
56103
56104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56105   int jresult ;
56106   int result;
56107
56108   {
56109     try {
56110       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56111     } catch (std::out_of_range& e) {
56112       {
56113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56114       };
56115     } catch (std::exception& e) {
56116       {
56117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56118       };
56119     } catch (Dali::DaliException e) {
56120       {
56121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56122       };
56123     } catch (...) {
56124       {
56125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56126       };
56127     }
56128   }
56129
56130   jresult = (int)result;
56131   return jresult;
56132 }
56133
56134
56135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56136   int jresult ;
56137   int result;
56138
56139   {
56140     try {
56141       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56142     } catch (std::out_of_range& e) {
56143       {
56144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56145       };
56146     } catch (std::exception& e) {
56147       {
56148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56149       };
56150     } catch (Dali::DaliException e) {
56151       {
56152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56153       };
56154     } catch (...) {
56155       {
56156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56157       };
56158     }
56159   }
56160
56161   jresult = (int)result;
56162   return jresult;
56163 }
56164
56165
56166 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56167   int jresult ;
56168   int result;
56169
56170   {
56171     try {
56172       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56173     } catch (std::out_of_range& e) {
56174       {
56175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56176       };
56177     } catch (std::exception& e) {
56178       {
56179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56180       };
56181     } catch (Dali::DaliException e) {
56182       {
56183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56184       };
56185     } catch (...) {
56186       {
56187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56188       };
56189     }
56190   }
56191
56192   jresult = (int)result;
56193   return jresult;
56194 }
56195
56196
56197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56198   int jresult ;
56199   int result;
56200
56201   {
56202     try {
56203       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56204     } catch (std::out_of_range& e) {
56205       {
56206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56207       };
56208     } catch (std::exception& e) {
56209       {
56210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56211       };
56212     } catch (Dali::DaliException e) {
56213       {
56214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56215       };
56216     } catch (...) {
56217       {
56218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56219       };
56220     }
56221   }
56222
56223   jresult = (int)result;
56224   return jresult;
56225 }
56226
56227
56228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56229   int jresult ;
56230   int result;
56231
56232   {
56233     try {
56234       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56235     } catch (std::out_of_range& e) {
56236       {
56237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56238       };
56239     } catch (std::exception& e) {
56240       {
56241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56242       };
56243     } catch (Dali::DaliException e) {
56244       {
56245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56246       };
56247     } catch (...) {
56248       {
56249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56250       };
56251     }
56252   }
56253
56254   jresult = (int)result;
56255   return jresult;
56256 }
56257
56258 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
56259   int jresult ;
56260   int result;
56261
56262   {
56263     try {
56264       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
56265     } catch (std::out_of_range& e) {
56266       {
56267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56268       };
56269     } catch (std::exception& e) {
56270       {
56271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56272       };
56273     } catch (...) {
56274       {
56275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56276       };
56277     }
56278   }
56279   jresult = (int)result;
56280   return jresult;
56281 }
56282
56283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56284   int jresult ;
56285   int result;
56286
56287   {
56288     try {
56289       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56290     } catch (std::out_of_range& e) {
56291       {
56292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56293       };
56294     } catch (std::exception& e) {
56295       {
56296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56297       };
56298     } catch (Dali::DaliException e) {
56299       {
56300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56301       };
56302     } catch (...) {
56303       {
56304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56305       };
56306     }
56307   }
56308
56309   jresult = (int)result;
56310   return jresult;
56311 }
56312
56313
56314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56315   int jresult ;
56316   int result;
56317
56318   {
56319     try {
56320       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56321     } catch (std::out_of_range& e) {
56322       {
56323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56324       };
56325     } catch (std::exception& e) {
56326       {
56327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56328       };
56329     } catch (Dali::DaliException e) {
56330       {
56331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56332       };
56333     } catch (...) {
56334       {
56335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56336       };
56337     }
56338   }
56339
56340   jresult = (int)result;
56341   return jresult;
56342 }
56343
56344
56345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56346   int jresult ;
56347   int result;
56348
56349   {
56350     try {
56351       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56352     } catch (std::out_of_range& e) {
56353       {
56354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56355       };
56356     } catch (std::exception& e) {
56357       {
56358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56359       };
56360     } catch (Dali::DaliException e) {
56361       {
56362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56363       };
56364     } catch (...) {
56365       {
56366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56367       };
56368     }
56369   }
56370
56371   jresult = (int)result;
56372   return jresult;
56373 }
56374
56375
56376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56377   int jresult ;
56378   int result;
56379
56380   {
56381     try {
56382       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56383     } catch (std::out_of_range& e) {
56384       {
56385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56386       };
56387     } catch (std::exception& e) {
56388       {
56389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56390       };
56391     } catch (Dali::DaliException e) {
56392       {
56393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56394       };
56395     } catch (...) {
56396       {
56397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56398       };
56399     }
56400   }
56401
56402   jresult = (int)result;
56403   return jresult;
56404 }
56405
56406
56407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56408   int jresult ;
56409   int result;
56410
56411   {
56412     try {
56413       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56414     } catch (std::out_of_range& e) {
56415       {
56416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56417       };
56418     } catch (std::exception& e) {
56419       {
56420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56421       };
56422     } catch (Dali::DaliException e) {
56423       {
56424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56425       };
56426     } catch (...) {
56427       {
56428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56429       };
56430     }
56431   }
56432
56433   jresult = (int)result;
56434   return jresult;
56435 }
56436
56437
56438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56439   int jresult ;
56440   int result;
56441
56442   {
56443     try {
56444       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56445     } catch (std::out_of_range& e) {
56446       {
56447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56448       };
56449     } catch (std::exception& e) {
56450       {
56451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56452       };
56453     } catch (Dali::DaliException e) {
56454       {
56455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56456       };
56457     } catch (...) {
56458       {
56459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56460       };
56461     }
56462   }
56463
56464   jresult = (int)result;
56465   return jresult;
56466 }
56467
56468
56469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56470   int jresult ;
56471   int result;
56472
56473   {
56474     try {
56475       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56476     } catch (std::out_of_range& e) {
56477       {
56478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56479       };
56480     } catch (std::exception& e) {
56481       {
56482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56483       };
56484     } catch (Dali::DaliException e) {
56485       {
56486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56487       };
56488     } catch (...) {
56489       {
56490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56491       };
56492     }
56493   }
56494
56495   jresult = (int)result;
56496   return jresult;
56497 }
56498
56499
56500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56501   int jresult ;
56502   int result;
56503
56504   {
56505     try {
56506       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56507     } catch (std::out_of_range& e) {
56508       {
56509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56510       };
56511     } catch (std::exception& e) {
56512       {
56513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56514       };
56515     } catch (Dali::DaliException e) {
56516       {
56517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56518       };
56519     } catch (...) {
56520       {
56521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56522       };
56523     }
56524   }
56525
56526   jresult = (int)result;
56527   return jresult;
56528 }
56529
56530
56531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56532   int jresult ;
56533   int result;
56534
56535   {
56536     try {
56537       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56538     } catch (std::out_of_range& e) {
56539       {
56540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56541       };
56542     } catch (std::exception& e) {
56543       {
56544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56545       };
56546     } catch (Dali::DaliException e) {
56547       {
56548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56549       };
56550     } catch (...) {
56551       {
56552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56553       };
56554     }
56555   }
56556
56557   jresult = (int)result;
56558   return jresult;
56559 }
56560
56561
56562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56563   int jresult ;
56564   int result;
56565
56566   {
56567     try {
56568       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56569     } catch (std::out_of_range& e) {
56570       {
56571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56572       };
56573     } catch (std::exception& e) {
56574       {
56575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56576       };
56577     } catch (Dali::DaliException e) {
56578       {
56579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56580       };
56581     } catch (...) {
56582       {
56583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56584       };
56585     }
56586   }
56587
56588   jresult = (int)result;
56589   return jresult;
56590 }
56591
56592
56593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
56594   int jresult ;
56595   int result;
56596
56597   {
56598     try {
56599       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56600     } catch (std::out_of_range& e) {
56601       {
56602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56603       };
56604     } catch (std::exception& e) {
56605       {
56606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56607       };
56608     } catch (Dali::DaliException e) {
56609       {
56610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56611       };
56612     } catch (...) {
56613       {
56614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56615       };
56616     }
56617   }
56618
56619   jresult = (int)result;
56620   return jresult;
56621 }
56622
56623
56624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
56625   int jresult ;
56626   int result;
56627
56628   {
56629     try {
56630       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56631     } catch (std::out_of_range& e) {
56632       {
56633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56634       };
56635     } catch (std::exception& e) {
56636       {
56637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56638       };
56639     } catch (Dali::DaliException e) {
56640       {
56641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56642       };
56643     } catch (...) {
56644       {
56645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56646       };
56647     }
56648   }
56649
56650   jresult = (int)result;
56651   return jresult;
56652 }
56653
56654
56655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
56656   int jresult ;
56657   int result;
56658
56659   {
56660     try {
56661       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
56662     } catch (std::out_of_range& e) {
56663       {
56664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56665       };
56666     } catch (std::exception& e) {
56667       {
56668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56669       };
56670     } catch (Dali::DaliException e) {
56671       {
56672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56673       };
56674     } catch (...) {
56675       {
56676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56677       };
56678     }
56679   }
56680
56681   jresult = (int)result;
56682   return jresult;
56683 }
56684
56685
56686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
56687   int jresult ;
56688   int result;
56689
56690   {
56691     try {
56692       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
56693     } catch (std::out_of_range& e) {
56694       {
56695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56696       };
56697     } catch (std::exception& e) {
56698       {
56699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56700       };
56701     } catch (Dali::DaliException e) {
56702       {
56703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56704       };
56705     } catch (...) {
56706       {
56707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56708       };
56709     }
56710   }
56711
56712   jresult = (int)result;
56713   return jresult;
56714 }
56715
56716
56717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
56718   int jresult ;
56719   int result;
56720
56721   {
56722     try {
56723       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
56724     } catch (std::out_of_range& e) {
56725       {
56726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56727       };
56728     } catch (std::exception& e) {
56729       {
56730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56731       };
56732     } catch (Dali::DaliException e) {
56733       {
56734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56735       };
56736     } catch (...) {
56737       {
56738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56739       };
56740     }
56741   }
56742
56743   jresult = (int)result;
56744   return jresult;
56745 }
56746
56747
56748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
56749   int jresult ;
56750   int result;
56751
56752   {
56753     try {
56754       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
56755     } catch (std::out_of_range& e) {
56756       {
56757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56758       };
56759     } catch (std::exception& e) {
56760       {
56761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56762       };
56763     } catch (Dali::DaliException e) {
56764       {
56765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56766       };
56767     } catch (...) {
56768       {
56769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56770       };
56771     }
56772   }
56773
56774   jresult = (int)result;
56775   return jresult;
56776 }
56777
56778
56779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
56780   int jresult ;
56781   int result;
56782
56783   {
56784     try {
56785       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
56786     } catch (std::out_of_range& e) {
56787       {
56788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56789       };
56790     } catch (std::exception& e) {
56791       {
56792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56793       };
56794     } catch (Dali::DaliException e) {
56795       {
56796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56797       };
56798     } catch (...) {
56799       {
56800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56801       };
56802     }
56803   }
56804
56805   jresult = (int)result;
56806   return jresult;
56807 }
56808
56809
56810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
56811   int jresult ;
56812   int result;
56813
56814   {
56815     try {
56816       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
56817     } catch (std::out_of_range& e) {
56818       {
56819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56820       };
56821     } catch (std::exception& e) {
56822       {
56823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56824       };
56825     } catch (Dali::DaliException e) {
56826       {
56827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56828       };
56829     } catch (...) {
56830       {
56831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56832       };
56833     }
56834   }
56835
56836   jresult = (int)result;
56837   return jresult;
56838 }
56839
56840
56841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
56842   int jresult ;
56843   int result;
56844
56845   {
56846     try {
56847       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
56848     } catch (std::out_of_range& e) {
56849       {
56850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56851       };
56852     } catch (std::exception& e) {
56853       {
56854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56855       };
56856     } catch (Dali::DaliException e) {
56857       {
56858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56859       };
56860     } catch (...) {
56861       {
56862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56863       };
56864     }
56865   }
56866
56867   jresult = (int)result;
56868   return jresult;
56869 }
56870
56871
56872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
56873   int jresult ;
56874   int result;
56875
56876   {
56877     try {
56878       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
56879     } catch (std::out_of_range& e) {
56880       {
56881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56882       };
56883     } catch (std::exception& e) {
56884       {
56885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56886       };
56887     } catch (Dali::DaliException e) {
56888       {
56889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56890       };
56891     } catch (...) {
56892       {
56893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56894       };
56895     }
56896   }
56897
56898   jresult = (int)result;
56899   return jresult;
56900 }
56901
56902
56903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
56904   int jresult ;
56905   int result;
56906
56907   {
56908     try {
56909       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
56910     } catch (std::out_of_range& e) {
56911       {
56912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56913       };
56914     } catch (std::exception& e) {
56915       {
56916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56917       };
56918     } catch (Dali::DaliException e) {
56919       {
56920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56921       };
56922     } catch (...) {
56923       {
56924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56925       };
56926     }
56927   }
56928
56929   jresult = (int)result;
56930   return jresult;
56931 }
56932
56933
56934 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
56935   int jresult ;
56936   int result;
56937
56938   {
56939     try {
56940       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
56941     } catch (std::out_of_range& e) {
56942       {
56943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56944       };
56945     } catch (std::exception& e) {
56946       {
56947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56948       };
56949     } catch (Dali::DaliException e) {
56950       {
56951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56952       };
56953     } catch (...) {
56954       {
56955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56956       };
56957     }
56958   }
56959
56960   jresult = (int)result;
56961   return jresult;
56962 }
56963
56964
56965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
56966   int jresult ;
56967   int result;
56968
56969   {
56970     try {
56971       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
56972     } catch (std::out_of_range& e) {
56973       {
56974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56975       };
56976     } catch (std::exception& e) {
56977       {
56978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56979       };
56980     } catch (Dali::DaliException e) {
56981       {
56982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56983       };
56984     } catch (...) {
56985       {
56986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56987       };
56988     }
56989   }
56990
56991   jresult = (int)result;
56992   return jresult;
56993 }
56994
56995
56996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
56997   int jresult ;
56998   int result;
56999
57000   {
57001     try {
57002       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57003     } catch (std::out_of_range& e) {
57004       {
57005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57006       };
57007     } catch (std::exception& e) {
57008       {
57009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57010       };
57011     } catch (Dali::DaliException e) {
57012       {
57013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57014       };
57015     } catch (...) {
57016       {
57017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57018       };
57019     }
57020   }
57021
57022   jresult = (int)result;
57023   return jresult;
57024 }
57025
57026
57027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57028   int jresult ;
57029   int result;
57030
57031   {
57032     try {
57033       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57034     } catch (std::out_of_range& e) {
57035       {
57036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57037       };
57038     } catch (std::exception& e) {
57039       {
57040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57041       };
57042     } catch (Dali::DaliException e) {
57043       {
57044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57045       };
57046     } catch (...) {
57047       {
57048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57049       };
57050     }
57051   }
57052
57053   jresult = (int)result;
57054   return jresult;
57055 }
57056
57057
57058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57059   int jresult ;
57060   int result;
57061
57062   {
57063     try {
57064       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57065     } catch (std::out_of_range& e) {
57066       {
57067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57068       };
57069     } catch (std::exception& e) {
57070       {
57071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57072       };
57073     } catch (Dali::DaliException e) {
57074       {
57075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57076       };
57077     } catch (...) {
57078       {
57079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57080       };
57081     }
57082   }
57083
57084   jresult = (int)result;
57085   return jresult;
57086 }
57087
57088
57089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57090   int jresult ;
57091   int result;
57092
57093   {
57094     try {
57095       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57096     } catch (std::out_of_range& e) {
57097       {
57098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57099       };
57100     } catch (std::exception& e) {
57101       {
57102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57103       };
57104     } catch (Dali::DaliException e) {
57105       {
57106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57107       };
57108     } catch (...) {
57109       {
57110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57111       };
57112     }
57113   }
57114
57115   jresult = (int)result;
57116   return jresult;
57117 }
57118
57119
57120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57121   int jresult ;
57122   int result;
57123
57124   {
57125     try {
57126       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57127     } catch (std::out_of_range& e) {
57128       {
57129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57130       };
57131     } catch (std::exception& e) {
57132       {
57133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57134       };
57135     } catch (Dali::DaliException e) {
57136       {
57137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57138       };
57139     } catch (...) {
57140       {
57141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57142       };
57143     }
57144   }
57145
57146   jresult = (int)result;
57147   return jresult;
57148 }
57149
57150
57151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57152   void * jresult ;
57153   Dali::Toolkit::Builder *result = 0 ;
57154
57155   {
57156     try {
57157       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57158     } catch (std::out_of_range& e) {
57159       {
57160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57161       };
57162     } catch (std::exception& e) {
57163       {
57164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57165       };
57166     } catch (Dali::DaliException e) {
57167       {
57168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57169       };
57170     } catch (...) {
57171       {
57172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57173       };
57174     }
57175   }
57176
57177   jresult = (void *)result;
57178   return jresult;
57179 }
57180
57181
57182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57183   void * jresult ;
57184   Dali::Toolkit::Builder result;
57185
57186   {
57187     try {
57188       result = Dali::Toolkit::Builder::New();
57189     } catch (std::out_of_range& e) {
57190       {
57191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57192       };
57193     } catch (std::exception& e) {
57194       {
57195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57196       };
57197     } catch (Dali::DaliException e) {
57198       {
57199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57200       };
57201     } catch (...) {
57202       {
57203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57204       };
57205     }
57206   }
57207
57208   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57209   return jresult;
57210 }
57211
57212
57213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57214   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57215
57216   arg1 = (Dali::Toolkit::Builder *)jarg1;
57217   {
57218     try {
57219       delete arg1;
57220     } catch (std::out_of_range& e) {
57221       {
57222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57223       };
57224     } catch (std::exception& e) {
57225       {
57226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57227       };
57228     } catch (Dali::DaliException e) {
57229       {
57230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57231       };
57232     } catch (...) {
57233       {
57234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57235       };
57236     }
57237   }
57238
57239 }
57240
57241
57242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57243   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57244   std::string *arg2 = 0 ;
57245   Dali::Toolkit::Builder::UIFormat arg3 ;
57246
57247   arg1 = (Dali::Toolkit::Builder *)jarg1;
57248   if (!jarg2) {
57249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57250     return ;
57251   }
57252   std::string arg2_str(jarg2);
57253   arg2 = &arg2_str;
57254   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57255   {
57256     try {
57257       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57258     } catch (std::out_of_range& e) {
57259       {
57260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57261       };
57262     } catch (std::exception& e) {
57263       {
57264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57265       };
57266     } catch (Dali::DaliException e) {
57267       {
57268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57269       };
57270     } catch (...) {
57271       {
57272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57273       };
57274     }
57275   }
57276
57277
57278   //argout typemap for const std::string&
57279
57280 }
57281
57282
57283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57284   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57285   std::string *arg2 = 0 ;
57286
57287   arg1 = (Dali::Toolkit::Builder *)jarg1;
57288   if (!jarg2) {
57289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57290     return ;
57291   }
57292   std::string arg2_str(jarg2);
57293   arg2 = &arg2_str;
57294   {
57295     try {
57296       (arg1)->LoadFromString((std::string const &)*arg2);
57297     } catch (std::out_of_range& e) {
57298       {
57299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57300       };
57301     } catch (std::exception& e) {
57302       {
57303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57304       };
57305     } catch (Dali::DaliException e) {
57306       {
57307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57308       };
57309     } catch (...) {
57310       {
57311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57312       };
57313     }
57314   }
57315
57316
57317   //argout typemap for const std::string&
57318
57319 }
57320
57321
57322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57323   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57324   Dali::Property::Map *arg2 = 0 ;
57325
57326   arg1 = (Dali::Toolkit::Builder *)jarg1;
57327   arg2 = (Dali::Property::Map *)jarg2;
57328   if (!arg2) {
57329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57330     return ;
57331   }
57332   {
57333     try {
57334       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57335     } catch (std::out_of_range& e) {
57336       {
57337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57338       };
57339     } catch (std::exception& e) {
57340       {
57341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57342       };
57343     } catch (Dali::DaliException e) {
57344       {
57345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57346       };
57347     } catch (...) {
57348       {
57349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57350       };
57351     }
57352   }
57353
57354 }
57355
57356
57357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57358   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57359   std::string *arg2 = 0 ;
57360   Dali::Property::Value *arg3 = 0 ;
57361
57362   arg1 = (Dali::Toolkit::Builder *)jarg1;
57363   if (!jarg2) {
57364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57365     return ;
57366   }
57367   std::string arg2_str(jarg2);
57368   arg2 = &arg2_str;
57369   arg3 = (Dali::Property::Value *)jarg3;
57370   if (!arg3) {
57371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57372     return ;
57373   }
57374   {
57375     try {
57376       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57377     } catch (std::out_of_range& e) {
57378       {
57379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57380       };
57381     } catch (std::exception& e) {
57382       {
57383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57384       };
57385     } catch (Dali::DaliException e) {
57386       {
57387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57388       };
57389     } catch (...) {
57390       {
57391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57392       };
57393     }
57394   }
57395
57396
57397   //argout typemap for const std::string&
57398
57399 }
57400
57401
57402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57403   void * jresult ;
57404   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57405   Dali::Property::Map *result = 0 ;
57406
57407   arg1 = (Dali::Toolkit::Builder *)jarg1;
57408   {
57409     try {
57410       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57411     } catch (std::out_of_range& e) {
57412       {
57413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57414       };
57415     } catch (std::exception& e) {
57416       {
57417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57418       };
57419     } catch (Dali::DaliException e) {
57420       {
57421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57422       };
57423     } catch (...) {
57424       {
57425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57426       };
57427     }
57428   }
57429
57430   jresult = (void *)result;
57431   return jresult;
57432 }
57433
57434
57435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57436   void * jresult ;
57437   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57438   std::string *arg2 = 0 ;
57439   Dali::Property::Value *result = 0 ;
57440
57441   arg1 = (Dali::Toolkit::Builder *)jarg1;
57442   if (!jarg2) {
57443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57444     return 0;
57445   }
57446   std::string arg2_str(jarg2);
57447   arg2 = &arg2_str;
57448   {
57449     try {
57450       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57451     } catch (std::out_of_range& e) {
57452       {
57453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57454       };
57455     } catch (std::exception& e) {
57456       {
57457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57458       };
57459     } catch (Dali::DaliException e) {
57460       {
57461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57462       };
57463     } catch (...) {
57464       {
57465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57466       };
57467     }
57468   }
57469
57470   jresult = (void *)result;
57471
57472   //argout typemap for const std::string&
57473
57474   return jresult;
57475 }
57476
57477
57478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57479   void * jresult ;
57480   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57481   std::string *arg2 = 0 ;
57482   Dali::Animation result;
57483
57484   arg1 = (Dali::Toolkit::Builder *)jarg1;
57485   if (!jarg2) {
57486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57487     return 0;
57488   }
57489   std::string arg2_str(jarg2);
57490   arg2 = &arg2_str;
57491   {
57492     try {
57493       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57494     } catch (std::out_of_range& e) {
57495       {
57496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57497       };
57498     } catch (std::exception& e) {
57499       {
57500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57501       };
57502     } catch (Dali::DaliException e) {
57503       {
57504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57505       };
57506     } catch (...) {
57507       {
57508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57509       };
57510     }
57511   }
57512
57513   jresult = new Dali::Animation((const Dali::Animation &)result);
57514
57515   //argout typemap for const std::string&
57516
57517   return jresult;
57518 }
57519
57520
57521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57522   void * jresult ;
57523   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57524   std::string *arg2 = 0 ;
57525   Dali::Property::Map *arg3 = 0 ;
57526   Dali::Animation result;
57527
57528   arg1 = (Dali::Toolkit::Builder *)jarg1;
57529   if (!jarg2) {
57530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57531     return 0;
57532   }
57533   std::string arg2_str(jarg2);
57534   arg2 = &arg2_str;
57535   arg3 = (Dali::Property::Map *)jarg3;
57536   if (!arg3) {
57537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57538     return 0;
57539   }
57540   {
57541     try {
57542       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57543     } catch (std::out_of_range& e) {
57544       {
57545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57546       };
57547     } catch (std::exception& e) {
57548       {
57549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57550       };
57551     } catch (Dali::DaliException e) {
57552       {
57553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57554       };
57555     } catch (...) {
57556       {
57557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57558       };
57559     }
57560   }
57561
57562   jresult = new Dali::Animation((const Dali::Animation &)result);
57563
57564   //argout typemap for const std::string&
57565
57566   return jresult;
57567 }
57568
57569
57570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57571   void * jresult ;
57572   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57573   std::string *arg2 = 0 ;
57574   Dali::Actor arg3 ;
57575   Dali::Actor *argp3 ;
57576   Dali::Animation result;
57577
57578   arg1 = (Dali::Toolkit::Builder *)jarg1;
57579   if (!jarg2) {
57580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57581     return 0;
57582   }
57583   std::string arg2_str(jarg2);
57584   arg2 = &arg2_str;
57585   argp3 = (Dali::Actor *)jarg3;
57586   if (!argp3) {
57587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57588     return 0;
57589   }
57590   arg3 = *argp3;
57591   {
57592     try {
57593       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57594     } catch (std::out_of_range& e) {
57595       {
57596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57597       };
57598     } catch (std::exception& e) {
57599       {
57600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57601       };
57602     } catch (Dali::DaliException e) {
57603       {
57604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57605       };
57606     } catch (...) {
57607       {
57608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57609       };
57610     }
57611   }
57612
57613   jresult = new Dali::Animation((const Dali::Animation &)result);
57614
57615   //argout typemap for const std::string&
57616
57617   return jresult;
57618 }
57619
57620
57621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57622   void * jresult ;
57623   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57624   std::string *arg2 = 0 ;
57625   Dali::Property::Map *arg3 = 0 ;
57626   Dali::Actor arg4 ;
57627   Dali::Actor *argp4 ;
57628   Dali::Animation result;
57629
57630   arg1 = (Dali::Toolkit::Builder *)jarg1;
57631   if (!jarg2) {
57632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57633     return 0;
57634   }
57635   std::string arg2_str(jarg2);
57636   arg2 = &arg2_str;
57637   arg3 = (Dali::Property::Map *)jarg3;
57638   if (!arg3) {
57639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57640     return 0;
57641   }
57642   argp4 = (Dali::Actor *)jarg4;
57643   if (!argp4) {
57644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57645     return 0;
57646   }
57647   arg4 = *argp4;
57648   {
57649     try {
57650       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57651     } catch (std::out_of_range& e) {
57652       {
57653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57654       };
57655     } catch (std::exception& e) {
57656       {
57657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57658       };
57659     } catch (Dali::DaliException e) {
57660       {
57661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57662       };
57663     } catch (...) {
57664       {
57665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57666       };
57667     }
57668   }
57669
57670   jresult = new Dali::Animation((const Dali::Animation &)result);
57671
57672   //argout typemap for const std::string&
57673
57674   return jresult;
57675 }
57676
57677
57678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
57679   void * jresult ;
57680   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57681   std::string *arg2 = 0 ;
57682   Dali::BaseHandle result;
57683
57684   arg1 = (Dali::Toolkit::Builder *)jarg1;
57685   if (!jarg2) {
57686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57687     return 0;
57688   }
57689   std::string arg2_str(jarg2);
57690   arg2 = &arg2_str;
57691   {
57692     try {
57693       result = (arg1)->Create((std::string const &)*arg2);
57694     } catch (std::out_of_range& e) {
57695       {
57696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57697       };
57698     } catch (std::exception& e) {
57699       {
57700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57701       };
57702     } catch (Dali::DaliException e) {
57703       {
57704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57705       };
57706     } catch (...) {
57707       {
57708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57709       };
57710     }
57711   }
57712
57713   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57714
57715   //argout typemap for const std::string&
57716
57717   return jresult;
57718 }
57719
57720
57721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57722   void * jresult ;
57723   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57724   std::string *arg2 = 0 ;
57725   Dali::Property::Map *arg3 = 0 ;
57726   Dali::BaseHandle result;
57727
57728   arg1 = (Dali::Toolkit::Builder *)jarg1;
57729   if (!jarg2) {
57730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57731     return 0;
57732   }
57733   std::string arg2_str(jarg2);
57734   arg2 = &arg2_str;
57735   arg3 = (Dali::Property::Map *)jarg3;
57736   if (!arg3) {
57737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57738     return 0;
57739   }
57740   {
57741     try {
57742       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57743     } catch (std::out_of_range& e) {
57744       {
57745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57746       };
57747     } catch (std::exception& e) {
57748       {
57749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57750       };
57751     } catch (Dali::DaliException e) {
57752       {
57753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57754       };
57755     } catch (...) {
57756       {
57757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57758       };
57759     }
57760   }
57761
57762   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57763
57764   //argout typemap for const std::string&
57765
57766   return jresult;
57767 }
57768
57769
57770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
57771   void * jresult ;
57772   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57773   std::string *arg2 = 0 ;
57774   Dali::BaseHandle result;
57775
57776   arg1 = (Dali::Toolkit::Builder *)jarg1;
57777   if (!jarg2) {
57778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57779     return 0;
57780   }
57781   std::string arg2_str(jarg2);
57782   arg2 = &arg2_str;
57783   {
57784     try {
57785       result = (arg1)->CreateFromJson((std::string const &)*arg2);
57786     } catch (std::out_of_range& e) {
57787       {
57788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57789       };
57790     } catch (std::exception& e) {
57791       {
57792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57793       };
57794     } catch (Dali::DaliException e) {
57795       {
57796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57797       };
57798     } catch (...) {
57799       {
57800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57801       };
57802     }
57803   }
57804
57805   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57806
57807   //argout typemap for const std::string&
57808
57809   return jresult;
57810 }
57811
57812
57813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
57814   unsigned int jresult ;
57815   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57816   std::string *arg2 = 0 ;
57817   Dali::Handle *arg3 = 0 ;
57818   bool result;
57819
57820   arg1 = (Dali::Toolkit::Builder *)jarg1;
57821   if (!jarg2) {
57822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57823     return 0;
57824   }
57825   std::string arg2_str(jarg2);
57826   arg2 = &arg2_str;
57827   arg3 = (Dali::Handle *)jarg3;
57828   if (!arg3) {
57829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57830     return 0;
57831   }
57832   {
57833     try {
57834       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
57835     } catch (std::out_of_range& e) {
57836       {
57837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57838       };
57839     } catch (std::exception& e) {
57840       {
57841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57842       };
57843     } catch (Dali::DaliException e) {
57844       {
57845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57846       };
57847     } catch (...) {
57848       {
57849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57850       };
57851     }
57852   }
57853
57854   jresult = result;
57855
57856   //argout typemap for const std::string&
57857
57858   return jresult;
57859 }
57860
57861
57862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
57863   unsigned int jresult ;
57864   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57865   Dali::Handle *arg2 = 0 ;
57866   std::string *arg3 = 0 ;
57867   bool result;
57868
57869   arg1 = (Dali::Toolkit::Builder *)jarg1;
57870   arg2 = (Dali::Handle *)jarg2;
57871   if (!arg2) {
57872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57873     return 0;
57874   }
57875   if (!jarg3) {
57876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57877     return 0;
57878   }
57879   std::string arg3_str(jarg3);
57880   arg3 = &arg3_str;
57881   {
57882     try {
57883       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
57884     } catch (std::out_of_range& e) {
57885       {
57886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57887       };
57888     } catch (std::exception& e) {
57889       {
57890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57891       };
57892     } catch (Dali::DaliException e) {
57893       {
57894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57895       };
57896     } catch (...) {
57897       {
57898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57899       };
57900     }
57901   }
57902
57903   jresult = result;
57904
57905   //argout typemap for const std::string&
57906
57907   return jresult;
57908 }
57909
57910
57911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
57912   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57913   Dali::Actor arg2 ;
57914   Dali::Actor *argp2 ;
57915
57916   arg1 = (Dali::Toolkit::Builder *)jarg1;
57917   argp2 = (Dali::Actor *)jarg2;
57918   if (!argp2) {
57919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57920     return ;
57921   }
57922   arg2 = *argp2;
57923   {
57924     try {
57925       (arg1)->AddActors(arg2);
57926     } catch (std::out_of_range& e) {
57927       {
57928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57929       };
57930     } catch (std::exception& e) {
57931       {
57932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57933       };
57934     } catch (Dali::DaliException e) {
57935       {
57936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57937       };
57938     } catch (...) {
57939       {
57940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57941       };
57942     }
57943   }
57944
57945 }
57946
57947
57948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57949   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57950   std::string *arg2 = 0 ;
57951   Dali::Actor arg3 ;
57952   Dali::Actor *argp3 ;
57953
57954   arg1 = (Dali::Toolkit::Builder *)jarg1;
57955   if (!jarg2) {
57956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57957     return ;
57958   }
57959   std::string arg2_str(jarg2);
57960   arg2 = &arg2_str;
57961   argp3 = (Dali::Actor *)jarg3;
57962   if (!argp3) {
57963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57964     return ;
57965   }
57966   arg3 = *argp3;
57967   {
57968     try {
57969       (arg1)->AddActors((std::string const &)*arg2,arg3);
57970     } catch (std::out_of_range& e) {
57971       {
57972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57973       };
57974     } catch (std::exception& e) {
57975       {
57976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57977       };
57978     } catch (Dali::DaliException e) {
57979       {
57980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57981       };
57982     } catch (...) {
57983       {
57984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57985       };
57986     }
57987   }
57988
57989
57990   //argout typemap for const std::string&
57991
57992 }
57993
57994
57995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
57996   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57997   std::string *arg2 = 0 ;
57998
57999   arg1 = (Dali::Toolkit::Builder *)jarg1;
58000   if (!jarg2) {
58001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58002     return ;
58003   }
58004   std::string arg2_str(jarg2);
58005   arg2 = &arg2_str;
58006   {
58007     try {
58008       (arg1)->CreateRenderTask((std::string const &)*arg2);
58009     } catch (std::out_of_range& e) {
58010       {
58011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58012       };
58013     } catch (std::exception& e) {
58014       {
58015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58016       };
58017     } catch (Dali::DaliException e) {
58018       {
58019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58020       };
58021     } catch (...) {
58022       {
58023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58024       };
58025     }
58026   }
58027
58028
58029   //argout typemap for const std::string&
58030
58031 }
58032
58033
58034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58035   void * jresult ;
58036   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58037   std::string *arg2 = 0 ;
58038   Dali::Path result;
58039
58040   arg1 = (Dali::Toolkit::Builder *)jarg1;
58041   if (!jarg2) {
58042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58043     return 0;
58044   }
58045   std::string arg2_str(jarg2);
58046   arg2 = &arg2_str;
58047   {
58048     try {
58049       result = (arg1)->GetPath((std::string const &)*arg2);
58050     } catch (std::out_of_range& e) {
58051       {
58052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58053       };
58054     } catch (std::exception& e) {
58055       {
58056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58057       };
58058     } catch (Dali::DaliException e) {
58059       {
58060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58061       };
58062     } catch (...) {
58063       {
58064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58065       };
58066     }
58067   }
58068
58069   jresult = new Dali::Path((const Dali::Path &)result);
58070
58071   //argout typemap for const std::string&
58072
58073   return jresult;
58074 }
58075
58076
58077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58078   void * jresult ;
58079   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58080   std::string *arg2 = 0 ;
58081   Dali::PathConstrainer result;
58082
58083   arg1 = (Dali::Toolkit::Builder *)jarg1;
58084   if (!jarg2) {
58085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58086     return 0;
58087   }
58088   std::string arg2_str(jarg2);
58089   arg2 = &arg2_str;
58090   {
58091     try {
58092       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58093     } catch (std::out_of_range& e) {
58094       {
58095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58096       };
58097     } catch (std::exception& e) {
58098       {
58099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58100       };
58101     } catch (Dali::DaliException e) {
58102       {
58103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58104       };
58105     } catch (...) {
58106       {
58107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58108       };
58109     }
58110   }
58111
58112   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58113
58114   //argout typemap for const std::string&
58115
58116   return jresult;
58117 }
58118
58119
58120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58121   void * jresult ;
58122   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58123   std::string *arg2 = 0 ;
58124   Dali::LinearConstrainer result;
58125
58126   arg1 = (Dali::Toolkit::Builder *)jarg1;
58127   if (!jarg2) {
58128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58129     return 0;
58130   }
58131   std::string arg2_str(jarg2);
58132   arg2 = &arg2_str;
58133   {
58134     try {
58135       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58136     } catch (std::out_of_range& e) {
58137       {
58138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58139       };
58140     } catch (std::exception& e) {
58141       {
58142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58143       };
58144     } catch (Dali::DaliException e) {
58145       {
58146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58147       };
58148     } catch (...) {
58149       {
58150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58151       };
58152     }
58153   }
58154
58155   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58156
58157   //argout typemap for const std::string&
58158
58159   return jresult;
58160 }
58161
58162
58163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58164   void * jresult ;
58165   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58166   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58167
58168   arg1 = (Dali::Toolkit::Builder *)jarg1;
58169   {
58170     try {
58171       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58172     } catch (std::out_of_range& e) {
58173       {
58174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58175       };
58176     } catch (std::exception& e) {
58177       {
58178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58179       };
58180     } catch (Dali::DaliException e) {
58181       {
58182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58183       };
58184     } catch (...) {
58185       {
58186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58187       };
58188     }
58189   }
58190
58191   jresult = (void *)result;
58192   return jresult;
58193 }
58194
58195
58196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58197   void * jresult ;
58198   Dali::Toolkit::TransitionData *result = 0 ;
58199
58200   {
58201     try {
58202       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58203     } catch (std::out_of_range& e) {
58204       {
58205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58206       };
58207     } catch (std::exception& e) {
58208       {
58209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58210       };
58211     } catch (Dali::DaliException e) {
58212       {
58213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58214       };
58215     } catch (...) {
58216       {
58217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58218       };
58219     }
58220   }
58221
58222   jresult = (void *)result;
58223   return jresult;
58224 }
58225
58226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58227   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58228
58229   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58230   {
58231     try {
58232       delete arg1;
58233     } catch (std::out_of_range& e) {
58234       {
58235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58236       };
58237     } catch (std::exception& e) {
58238       {
58239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58240       };
58241     } catch (Dali::DaliException e) {
58242       {
58243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58244       };
58245     } catch (...) {
58246       {
58247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58248       };
58249     }
58250   }
58251
58252 }
58253
58254
58255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58256   void * jresult ;
58257   Dali::Property::Map *arg1 = 0 ;
58258   Dali::Toolkit::TransitionData result;
58259
58260   arg1 = (Dali::Property::Map *)jarg1;
58261   if (!arg1) {
58262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58263     return 0;
58264   }
58265   {
58266     try {
58267       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58268     } catch (std::out_of_range& e) {
58269       {
58270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58271       };
58272     } catch (std::exception& e) {
58273       {
58274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58275       };
58276     } catch (Dali::DaliException e) {
58277       {
58278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58279       };
58280     } catch (...) {
58281       {
58282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58283       };
58284     }
58285   }
58286
58287   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58288   return jresult;
58289 }
58290
58291
58292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58293   void * jresult ;
58294   Dali::Property::Array *arg1 = 0 ;
58295   Dali::Toolkit::TransitionData result;
58296
58297   arg1 = (Dali::Property::Array *)jarg1;
58298   if (!arg1) {
58299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58300     return 0;
58301   }
58302   {
58303     try {
58304       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58305     } catch (std::out_of_range& e) {
58306       {
58307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58308       };
58309     } catch (std::exception& e) {
58310       {
58311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58312       };
58313     } catch (Dali::DaliException e) {
58314       {
58315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58316       };
58317     } catch (...) {
58318       {
58319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58320       };
58321     }
58322   }
58323
58324   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58325   return jresult;
58326 }
58327
58328
58329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58330   void * jresult ;
58331   Dali::BaseHandle arg1 ;
58332   Dali::BaseHandle *argp1 ;
58333   Dali::Toolkit::TransitionData result;
58334
58335   argp1 = (Dali::BaseHandle *)jarg1;
58336   if (!argp1) {
58337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58338     return 0;
58339   }
58340   arg1 = *argp1;
58341   {
58342     try {
58343       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58344     } catch (std::out_of_range& e) {
58345       {
58346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58347       };
58348     } catch (std::exception& e) {
58349       {
58350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58351       };
58352     } catch (Dali::DaliException e) {
58353       {
58354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58355       };
58356     } catch (...) {
58357       {
58358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58359       };
58360     }
58361   }
58362
58363   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58364   return jresult;
58365 }
58366
58367
58368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58369   void * jresult ;
58370   Dali::Toolkit::TransitionData *arg1 = 0 ;
58371   Dali::Toolkit::TransitionData *result = 0 ;
58372
58373   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58374   if (!arg1) {
58375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58376     return 0;
58377   }
58378   {
58379     try {
58380       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58381     } catch (std::out_of_range& e) {
58382       {
58383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58384       };
58385     } catch (std::exception& e) {
58386       {
58387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58388       };
58389     } catch (Dali::DaliException e) {
58390       {
58391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58392       };
58393     } catch (...) {
58394       {
58395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58396       };
58397     }
58398   }
58399
58400   jresult = (void *)result;
58401   return jresult;
58402 }
58403
58404
58405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58406   void * jresult ;
58407   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58408   Dali::Toolkit::TransitionData *arg2 = 0 ;
58409   Dali::Toolkit::TransitionData *result = 0 ;
58410
58411   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58412   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58413   if (!arg2) {
58414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58415     return 0;
58416   }
58417   {
58418     try {
58419       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58420     } catch (std::out_of_range& e) {
58421       {
58422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58423       };
58424     } catch (std::exception& e) {
58425       {
58426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58427       };
58428     } catch (Dali::DaliException e) {
58429       {
58430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58431       };
58432     } catch (...) {
58433       {
58434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58435       };
58436     }
58437   }
58438
58439   jresult = (void *)result;
58440   return jresult;
58441 }
58442
58443
58444 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58445   unsigned long jresult ;
58446   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58447   size_t result;
58448
58449   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58450   {
58451     try {
58452       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58453     } catch (std::out_of_range& e) {
58454       {
58455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58456       };
58457     } catch (std::exception& e) {
58458       {
58459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58460       };
58461     } catch (Dali::DaliException e) {
58462       {
58463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58464       };
58465     } catch (...) {
58466       {
58467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58468       };
58469     }
58470   }
58471
58472   jresult = (unsigned long)result;
58473   return jresult;
58474 }
58475
58476
58477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58478   void * jresult ;
58479   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58480   size_t arg2 ;
58481   Dali::Property::Map result;
58482
58483   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58484   arg2 = (size_t)jarg2;
58485   {
58486     try {
58487       result = (arg1)->GetAnimatorAt(arg2);
58488     } catch (std::out_of_range& e) {
58489       {
58490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58491       };
58492     } catch (std::exception& e) {
58493       {
58494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58495       };
58496     } catch (Dali::DaliException e) {
58497       {
58498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58499       };
58500     } catch (...) {
58501       {
58502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58503       };
58504     }
58505   }
58506
58507   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58508   return jresult;
58509 }
58510
58511
58512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58513   int jresult ;
58514   int result;
58515
58516   {
58517     try {
58518       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58519     } catch (std::out_of_range& e) {
58520       {
58521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58522       };
58523     } catch (std::exception& e) {
58524       {
58525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58526       };
58527     } catch (Dali::DaliException e) {
58528       {
58529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58530       };
58531     } catch (...) {
58532       {
58533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58534       };
58535     }
58536   }
58537
58538   jresult = (int)result;
58539   return jresult;
58540 }
58541
58542
58543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58544   int jresult ;
58545   int result;
58546
58547   {
58548     try {
58549       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58550     } catch (std::out_of_range& e) {
58551       {
58552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58553       };
58554     } catch (std::exception& e) {
58555       {
58556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58557       };
58558     } catch (Dali::DaliException e) {
58559       {
58560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58561       };
58562     } catch (...) {
58563       {
58564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58565       };
58566     }
58567   }
58568
58569   jresult = (int)result;
58570   return jresult;
58571 }
58572
58573
58574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58575   int jresult ;
58576   int result;
58577
58578   {
58579     try {
58580       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58581     } catch (std::out_of_range& e) {
58582       {
58583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58584       };
58585     } catch (std::exception& e) {
58586       {
58587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58588       };
58589     } catch (Dali::DaliException e) {
58590       {
58591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58592       };
58593     } catch (...) {
58594       {
58595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58596       };
58597     }
58598   }
58599
58600   jresult = (int)result;
58601   return jresult;
58602 }
58603
58604
58605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58606   int jresult ;
58607   int result;
58608
58609   {
58610     try {
58611       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58612     } catch (std::out_of_range& e) {
58613       {
58614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58615       };
58616     } catch (std::exception& e) {
58617       {
58618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58619       };
58620     } catch (Dali::DaliException e) {
58621       {
58622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58623       };
58624     } catch (...) {
58625       {
58626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58627       };
58628     }
58629   }
58630
58631   jresult = (int)result;
58632   return jresult;
58633 }
58634
58635
58636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58637   int jresult ;
58638   int result;
58639
58640   {
58641     try {
58642       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58643     } catch (std::out_of_range& e) {
58644       {
58645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58646       };
58647     } catch (std::exception& e) {
58648       {
58649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58650       };
58651     } catch (Dali::DaliException e) {
58652       {
58653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58654       };
58655     } catch (...) {
58656       {
58657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58658       };
58659     }
58660   }
58661
58662   jresult = (int)result;
58663   return jresult;
58664 }
58665
58666
58667 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58668   int jresult ;
58669   int result;
58670
58671   {
58672     try {
58673       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
58674     } catch (std::out_of_range& e) {
58675       {
58676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58677       };
58678     } catch (std::exception& e) {
58679       {
58680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58681       };
58682     } catch (Dali::DaliException e) {
58683       {
58684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58685       };
58686     } catch (...) {
58687       {
58688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58689       };
58690     }
58691   }
58692
58693   jresult = (int)result;
58694   return jresult;
58695 }
58696
58697
58698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
58699   int jresult ;
58700   int result;
58701
58702   {
58703     try {
58704       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
58705     } catch (std::out_of_range& e) {
58706       {
58707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58708       };
58709     } catch (std::exception& e) {
58710       {
58711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58712       };
58713     } catch (Dali::DaliException e) {
58714       {
58715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58716       };
58717     } catch (...) {
58718       {
58719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58720       };
58721     }
58722   }
58723
58724   jresult = (int)result;
58725   return jresult;
58726 }
58727
58728
58729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
58730   int jresult ;
58731   int result;
58732
58733   {
58734     try {
58735       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
58736     } catch (std::out_of_range& e) {
58737       {
58738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58739       };
58740     } catch (std::exception& e) {
58741       {
58742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58743       };
58744     } catch (Dali::DaliException e) {
58745       {
58746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58747       };
58748     } catch (...) {
58749       {
58750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58751       };
58752     }
58753   }
58754
58755   jresult = (int)result;
58756   return jresult;
58757 }
58758
58759
58760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
58761   int jresult ;
58762   int result;
58763
58764   {
58765     try {
58766       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
58767     } catch (std::out_of_range& e) {
58768       {
58769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58770       };
58771     } catch (std::exception& e) {
58772       {
58773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58774       };
58775     } catch (Dali::DaliException e) {
58776       {
58777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58778       };
58779     } catch (...) {
58780       {
58781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58782       };
58783     }
58784   }
58785
58786   jresult = (int)result;
58787   return jresult;
58788 }
58789
58790
58791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
58792   int jresult ;
58793   int result;
58794
58795   {
58796     try {
58797       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
58798     } catch (std::out_of_range& e) {
58799       {
58800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58801       };
58802     } catch (std::exception& e) {
58803       {
58804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58805       };
58806     } catch (Dali::DaliException e) {
58807       {
58808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58809       };
58810     } catch (...) {
58811       {
58812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58813       };
58814     }
58815   }
58816
58817   jresult = (int)result;
58818   return jresult;
58819 }
58820
58821
58822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
58823   int jresult ;
58824   int result;
58825
58826   {
58827     try {
58828       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
58829     } catch (std::out_of_range& e) {
58830       {
58831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58832       };
58833     } catch (std::exception& e) {
58834       {
58835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58836       };
58837     } catch (Dali::DaliException e) {
58838       {
58839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58840       };
58841     } catch (...) {
58842       {
58843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58844       };
58845     }
58846   }
58847
58848   jresult = (int)result;
58849   return jresult;
58850 }
58851
58852
58853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
58854   int jresult ;
58855   int result;
58856
58857   {
58858     try {
58859       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
58860     } catch (std::out_of_range& e) {
58861       {
58862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58863       };
58864     } catch (std::exception& e) {
58865       {
58866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58867       };
58868     } catch (Dali::DaliException e) {
58869       {
58870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58871       };
58872     } catch (...) {
58873       {
58874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58875       };
58876     }
58877   }
58878
58879   jresult = (int)result;
58880   return jresult;
58881 }
58882
58883
58884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
58885   int jresult ;
58886   int result;
58887
58888   {
58889     try {
58890       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
58891     } catch (std::out_of_range& e) {
58892       {
58893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58894       };
58895     } catch (std::exception& e) {
58896       {
58897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58898       };
58899     } catch (Dali::DaliException e) {
58900       {
58901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58902       };
58903     } catch (...) {
58904       {
58905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58906       };
58907     }
58908   }
58909
58910   jresult = (int)result;
58911   return jresult;
58912 }
58913
58914
58915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
58916   int jresult ;
58917   int result;
58918
58919   {
58920     try {
58921       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
58922     } catch (std::out_of_range& e) {
58923       {
58924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58925       };
58926     } catch (std::exception& e) {
58927       {
58928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58929       };
58930     } catch (Dali::DaliException e) {
58931       {
58932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58933       };
58934     } catch (...) {
58935       {
58936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58937       };
58938     }
58939   }
58940
58941   jresult = (int)result;
58942   return jresult;
58943 }
58944
58945
58946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
58947   void * jresult ;
58948   Dali::Toolkit::Control result;
58949
58950   {
58951     try {
58952       result = Dali::Toolkit::Internal::Control::New();
58953     } catch (std::out_of_range& e) {
58954       {
58955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58956       };
58957     } catch (std::exception& e) {
58958       {
58959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58960       };
58961     } catch (Dali::DaliException e) {
58962       {
58963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58964       };
58965     } catch (...) {
58966       {
58967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58968       };
58969     }
58970   }
58971
58972   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
58973   return jresult;
58974 }
58975
58976
58977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
58978   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
58979   std::string *arg2 = 0 ;
58980
58981   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
58982   if (!jarg2) {
58983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58984     return ;
58985   }
58986   std::string arg2_str(jarg2);
58987   arg2 = &arg2_str;
58988   {
58989     try {
58990       (arg1)->SetStyleName((std::string const &)*arg2);
58991     } catch (std::out_of_range& e) {
58992       {
58993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58994       };
58995     } catch (std::exception& e) {
58996       {
58997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58998       };
58999     } catch (Dali::DaliException e) {
59000       {
59001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59002       };
59003     } catch (...) {
59004       {
59005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59006       };
59007     }
59008   }
59009
59010
59011   //argout typemap for const std::string&
59012
59013 }
59014
59015
59016 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59017   char * jresult ;
59018   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59019   std::string *result = 0 ;
59020
59021   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59022   {
59023     try {
59024       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59025     } catch (std::out_of_range& e) {
59026       {
59027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59028       };
59029     } catch (std::exception& e) {
59030       {
59031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59032       };
59033     } catch (Dali::DaliException e) {
59034       {
59035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59036       };
59037     } catch (...) {
59038       {
59039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59040       };
59041     }
59042   }
59043
59044   jresult = SWIG_csharp_string_callback(result->c_str());
59045   return jresult;
59046 }
59047
59048
59049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59050   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59051   Dali::Vector4 *arg2 = 0 ;
59052
59053   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59054   arg2 = (Dali::Vector4 *)jarg2;
59055   if (!arg2) {
59056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59057     return ;
59058   }
59059   {
59060     try {
59061       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59062     } catch (std::out_of_range& e) {
59063       {
59064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59065       };
59066     } catch (std::exception& e) {
59067       {
59068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59069       };
59070     } catch (Dali::DaliException e) {
59071       {
59072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59073       };
59074     } catch (...) {
59075       {
59076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59077       };
59078     }
59079   }
59080
59081 }
59082
59083
59084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
59085   void * jresult ;
59086   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
59087   Dali::Vector4 result;
59088
59089   arg1 = (Dali::Handle *)jarg1;
59090   {
59091     try {
59092       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
59093       if (resultMap)
59094       {
59095         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
59096         if(type && type->Get<int>() == Visual::COLOR )
59097         {
59098           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
59099           if (value)
59100           {
59101             result = value->Get<Vector4>();
59102           }
59103         }
59104       }
59105     } catch (std::out_of_range& e) {
59106       {
59107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59108       };
59109     } catch (std::exception& e) {
59110       {
59111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59112       };
59113     } catch (Dali::DaliException e) {
59114       {
59115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59116       };
59117     } catch (...) {
59118       {
59119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59120       };
59121     }
59122   }
59123
59124   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59125   return jresult;
59126 }
59127
59128
59129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59130   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59131   Dali::Property::Map *arg2 = 0 ;
59132
59133   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59134   arg2 = (Dali::Property::Map *)jarg2;
59135   if (!arg2) {
59136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59137     return ;
59138   }
59139   {
59140     try {
59141       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59142     } catch (std::out_of_range& e) {
59143       {
59144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59145       };
59146     } catch (std::exception& e) {
59147       {
59148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59149       };
59150     } catch (Dali::DaliException e) {
59151       {
59152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59153       };
59154     } catch (...) {
59155       {
59156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59157       };
59158     }
59159   }
59160
59161 }
59162
59163
59164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59165   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59166
59167   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59168   {
59169     try {
59170       (arg1)->ClearBackground();
59171     } catch (std::out_of_range& e) {
59172       {
59173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59174       };
59175     } catch (std::exception& e) {
59176       {
59177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59178       };
59179     } catch (Dali::DaliException e) {
59180       {
59181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59182       };
59183     } catch (...) {
59184       {
59185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59186       };
59187     }
59188   }
59189
59190 }
59191
59192
59193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59194   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59195   Dali::Gesture::Type arg2 ;
59196
59197   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59198   arg2 = (Dali::Gesture::Type)jarg2;
59199   {
59200     try {
59201       (arg1)->EnableGestureDetection(arg2);
59202     } catch (std::out_of_range& e) {
59203       {
59204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59205       };
59206     } catch (std::exception& e) {
59207       {
59208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59209       };
59210     } catch (Dali::DaliException e) {
59211       {
59212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59213       };
59214     } catch (...) {
59215       {
59216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59217       };
59218     }
59219   }
59220
59221 }
59222
59223
59224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59225   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59226   Dali::Gesture::Type arg2 ;
59227
59228   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59229   arg2 = (Dali::Gesture::Type)jarg2;
59230   {
59231     try {
59232       (arg1)->DisableGestureDetection(arg2);
59233     } catch (std::out_of_range& e) {
59234       {
59235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59236       };
59237     } catch (std::exception& e) {
59238       {
59239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59240       };
59241     } catch (Dali::DaliException e) {
59242       {
59243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59244       };
59245     } catch (...) {
59246       {
59247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59248       };
59249     }
59250   }
59251
59252 }
59253
59254
59255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59256   void * jresult ;
59257   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59258   Dali::PinchGestureDetector result;
59259
59260   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59261   {
59262     try {
59263       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59264     } catch (std::out_of_range& e) {
59265       {
59266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59267       };
59268     } catch (std::exception& e) {
59269       {
59270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59271       };
59272     } catch (Dali::DaliException e) {
59273       {
59274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59275       };
59276     } catch (...) {
59277       {
59278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59279       };
59280     }
59281   }
59282
59283   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59284   return jresult;
59285 }
59286
59287
59288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59289   void * jresult ;
59290   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59291   Dali::PanGestureDetector result;
59292
59293   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59294   {
59295     try {
59296       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59297     } catch (std::out_of_range& e) {
59298       {
59299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59300       };
59301     } catch (std::exception& e) {
59302       {
59303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59304       };
59305     } catch (Dali::DaliException e) {
59306       {
59307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59308       };
59309     } catch (...) {
59310       {
59311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59312       };
59313     }
59314   }
59315
59316   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59317   return jresult;
59318 }
59319
59320
59321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59322   void * jresult ;
59323   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59324   Dali::TapGestureDetector result;
59325
59326   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59327   {
59328     try {
59329       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59330     } catch (std::out_of_range& e) {
59331       {
59332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59333       };
59334     } catch (std::exception& e) {
59335       {
59336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59337       };
59338     } catch (Dali::DaliException e) {
59339       {
59340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59341       };
59342     } catch (...) {
59343       {
59344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59345       };
59346     }
59347   }
59348
59349   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59350   return jresult;
59351 }
59352
59353
59354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59355   void * jresult ;
59356   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59357   Dali::LongPressGestureDetector result;
59358
59359   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59360   {
59361     try {
59362       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59363     } catch (std::out_of_range& e) {
59364       {
59365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59366       };
59367     } catch (std::exception& e) {
59368       {
59369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59370       };
59371     } catch (Dali::DaliException e) {
59372       {
59373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59374       };
59375     } catch (...) {
59376       {
59377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59378       };
59379     }
59380   }
59381
59382   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59383   return jresult;
59384 }
59385
59386
59387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59388   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59389   bool arg2 ;
59390
59391   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59392   arg2 = jarg2 ? true : false;
59393   {
59394     try {
59395       (arg1)->SetKeyboardNavigationSupport(arg2);
59396     } catch (std::out_of_range& e) {
59397       {
59398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59399       };
59400     } catch (std::exception& e) {
59401       {
59402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59403       };
59404     } catch (Dali::DaliException e) {
59405       {
59406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59407       };
59408     } catch (...) {
59409       {
59410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59411       };
59412     }
59413   }
59414
59415 }
59416
59417
59418 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59419   unsigned int jresult ;
59420   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59421   bool result;
59422
59423   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59424   {
59425     try {
59426       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59427     } catch (std::out_of_range& e) {
59428       {
59429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59430       };
59431     } catch (std::exception& e) {
59432       {
59433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59434       };
59435     } catch (Dali::DaliException e) {
59436       {
59437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59438       };
59439     } catch (...) {
59440       {
59441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59442       };
59443     }
59444   }
59445
59446   jresult = result;
59447   return jresult;
59448 }
59449
59450
59451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59452   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59453
59454   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59455   {
59456     try {
59457       (arg1)->SetKeyInputFocus();
59458     } catch (std::out_of_range& e) {
59459       {
59460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59461       };
59462     } catch (std::exception& e) {
59463       {
59464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59465       };
59466     } catch (Dali::DaliException e) {
59467       {
59468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59469       };
59470     } catch (...) {
59471       {
59472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59473       };
59474     }
59475   }
59476
59477 }
59478
59479
59480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
59481   unsigned int jresult ;
59482   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59483   bool result;
59484
59485   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59486   {
59487     try {
59488       result = (bool)(arg1)->HasKeyInputFocus();
59489     } catch (std::out_of_range& e) {
59490       {
59491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59492       };
59493     } catch (std::exception& e) {
59494       {
59495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59496       };
59497     } catch (Dali::DaliException e) {
59498       {
59499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59500       };
59501     } catch (...) {
59502       {
59503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59504       };
59505     }
59506   }
59507
59508   jresult = result;
59509   return jresult;
59510 }
59511
59512
59513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
59514   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59515
59516   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59517   {
59518     try {
59519       (arg1)->ClearKeyInputFocus();
59520     } catch (std::out_of_range& e) {
59521       {
59522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59523       };
59524     } catch (std::exception& e) {
59525       {
59526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59527       };
59528     } catch (Dali::DaliException e) {
59529       {
59530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59531       };
59532     } catch (...) {
59533       {
59534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59535       };
59536     }
59537   }
59538
59539 }
59540
59541
59542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
59543   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59544   bool arg2 ;
59545
59546   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59547   arg2 = jarg2 ? true : false;
59548   {
59549     try {
59550       (arg1)->SetAsKeyboardFocusGroup(arg2);
59551     } catch (std::out_of_range& e) {
59552       {
59553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59554       };
59555     } catch (std::exception& e) {
59556       {
59557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59558       };
59559     } catch (Dali::DaliException e) {
59560       {
59561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59562       };
59563     } catch (...) {
59564       {
59565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59566       };
59567     }
59568   }
59569
59570 }
59571
59572
59573 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
59574   unsigned int jresult ;
59575   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59576   bool result;
59577
59578   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59579   {
59580     try {
59581       result = (bool)(arg1)->IsKeyboardFocusGroup();
59582     } catch (std::out_of_range& e) {
59583       {
59584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59585       };
59586     } catch (std::exception& e) {
59587       {
59588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59589       };
59590     } catch (Dali::DaliException e) {
59591       {
59592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59593       };
59594     } catch (...) {
59595       {
59596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59597       };
59598     }
59599   }
59600
59601   jresult = result;
59602   return jresult;
59603 }
59604
59605
59606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59607   void * jresult ;
59608   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59609   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59610
59611   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59612   {
59613     try {
59614       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59615     } catch (std::out_of_range& e) {
59616       {
59617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59618       };
59619     } catch (std::exception& e) {
59620       {
59621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59622       };
59623     } catch (Dali::DaliException e) {
59624       {
59625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59626       };
59627     } catch (...) {
59628       {
59629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59630       };
59631     }
59632   }
59633
59634   jresult = (void *)result;
59635   return jresult;
59636 }
59637
59638
59639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59640   void * jresult ;
59641   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59642   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59643
59644   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59645   {
59646     try {
59647       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59648     } catch (std::out_of_range& e) {
59649       {
59650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59651       };
59652     } catch (std::exception& e) {
59653       {
59654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59655       };
59656     } catch (Dali::DaliException e) {
59657       {
59658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59659       };
59660     } catch (...) {
59661       {
59662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59663       };
59664     }
59665   }
59666
59667   jresult = (void *)result;
59668   return jresult;
59669 }
59670
59671
59672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59673   void * jresult ;
59674   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59675   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59676
59677   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59678   {
59679     try {
59680       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59681     } catch (std::out_of_range& e) {
59682       {
59683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59684       };
59685     } catch (std::exception& e) {
59686       {
59687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59688       };
59689     } catch (Dali::DaliException e) {
59690       {
59691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59692       };
59693     } catch (...) {
59694       {
59695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59696       };
59697     }
59698   }
59699
59700   jresult = (void *)result;
59701   return jresult;
59702 }
59703
59704
59705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
59706   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59707   int arg2 ;
59708   SwigDirector_ViewImpl *darg = 0;
59709
59710   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59711   arg2 = (int)jarg2;
59712   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59713   if(!darg) {
59714     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59715     return;
59716   }
59717   {
59718     try {
59719       if(darg) {
59720         (darg)->OnSceneConnection(arg2);
59721       }
59722     } catch (std::out_of_range& e) {
59723       {
59724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59725       };
59726     } catch (std::exception& e) {
59727       {
59728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59729       };
59730     } catch (Dali::DaliException e) {
59731       {
59732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59733       };
59734     } catch (...) {
59735       {
59736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59737       };
59738     }
59739   }
59740
59741 }
59742
59743
59744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
59745   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59746   int arg2 ;
59747   SwigDirector_ViewImpl *darg = 0;
59748
59749   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59750   arg2 = (int)jarg2;
59751   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59752   if(!darg) {
59753     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59754     return;
59755   }
59756   {
59757     try {
59758       if(darg) {
59759         (darg)->OnSceneConnectionSwigPublic(arg2);
59760       }
59761     } catch (std::out_of_range& e) {
59762       {
59763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59764       };
59765     } catch (std::exception& e) {
59766       {
59767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59768       };
59769     } catch (Dali::DaliException e) {
59770       {
59771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59772       };
59773     } catch (...) {
59774       {
59775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59776       };
59777     }
59778   }
59779
59780 }
59781
59782
59783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
59784   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59785   SwigDirector_ViewImpl *darg = 0;
59786
59787   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59788   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59789   if(!darg) {
59790     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59791     return;
59792   }
59793   {
59794     try {
59795       if(darg) {
59796         (darg)->OnSceneDisconnection();
59797       }
59798     } catch (std::out_of_range& e) {
59799       {
59800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59801       };
59802     } catch (std::exception& e) {
59803       {
59804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59805       };
59806     } catch (Dali::DaliException e) {
59807       {
59808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59809       };
59810     } catch (...) {
59811       {
59812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59813       };
59814     }
59815   }
59816
59817 }
59818
59819
59820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
59821   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59822   SwigDirector_ViewImpl *darg = 0;
59823
59824   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59825   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59826   if(!darg) {
59827     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59828     return;
59829   }
59830   {
59831     try {
59832       if(darg) {
59833         (darg)->OnSceneDisconnectionSwigPublic();
59834       }
59835     } catch (std::out_of_range& e) {
59836       {
59837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59838       };
59839     } catch (std::exception& e) {
59840       {
59841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59842       };
59843     } catch (Dali::DaliException e) {
59844       {
59845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59846       };
59847     } catch (...) {
59848       {
59849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59850       };
59851     }
59852   }
59853
59854 }
59855
59856
59857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
59858   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59859   Dali::Actor *arg2 = 0 ;
59860   SwigDirector_ViewImpl *darg = 0;
59861
59862   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59863   arg2 = (Dali::Actor *)jarg2;
59864   if (!arg2) {
59865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59866     return ;
59867   }
59868   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59869   if(!darg) {
59870     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59871     return;
59872   }
59873   {
59874     try {
59875       if(darg) {
59876         (darg)->OnChildAdd(*arg2);
59877       }
59878     } catch (std::out_of_range& e) {
59879       {
59880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59881       };
59882     } catch (std::exception& e) {
59883       {
59884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59885       };
59886     } catch (Dali::DaliException e) {
59887       {
59888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59889       };
59890     } catch (...) {
59891       {
59892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59893       };
59894     }
59895   }
59896
59897 }
59898
59899
59900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59901   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59902   Dali::Actor *arg2 = 0 ;
59903   SwigDirector_ViewImpl *darg = 0;
59904
59905   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59906   arg2 = (Dali::Actor *)jarg2;
59907   if (!arg2) {
59908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59909     return ;
59910   }
59911   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59912   if(!darg) {
59913     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59914     return;
59915   }
59916   {
59917     try {
59918       if(darg) {
59919           (darg)->OnChildAddSwigPublic(*arg2);
59920       }
59921     } catch (std::out_of_range& e) {
59922       {
59923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59924       };
59925     } catch (std::exception& e) {
59926       {
59927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59928       };
59929     } catch (Dali::DaliException e) {
59930       {
59931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59932       };
59933     } catch (...) {
59934       {
59935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59936       };
59937     }
59938   }
59939
59940 }
59941
59942
59943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
59944   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59945   Dali::Actor *arg2 = 0 ;
59946   SwigDirector_ViewImpl *darg = 0;
59947
59948   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59949   arg2 = (Dali::Actor *)jarg2;
59950   if (!arg2) {
59951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59952     return ;
59953   }
59954   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59955   if(!darg) {
59956     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59957     return;
59958   }
59959   {
59960     try {
59961       if(darg) {
59962         (darg)->OnChildRemove(*arg2);
59963       }
59964     } catch (std::out_of_range& e) {
59965       {
59966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59967       };
59968     } catch (std::exception& e) {
59969       {
59970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59971       };
59972     } catch (Dali::DaliException e) {
59973       {
59974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59975       };
59976     } catch (...) {
59977       {
59978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59979       };
59980     }
59981   }
59982
59983 }
59984
59985
59986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59987   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59988   Dali::Actor *arg2 = 0 ;
59989   SwigDirector_ViewImpl *darg = 0;
59990
59991   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59992   arg2 = (Dali::Actor *)jarg2;
59993   if (!arg2) {
59994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59995     return ;
59996   }
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)->OnChildRemoveSwigPublic(*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_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60030   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60031   Dali::Property::Index arg2 ;
60032   Dali::Property::Value arg3 ;
60033   Dali::Property::Value *argp3 ;
60034   SwigDirector_ViewImpl *darg = 0;
60035
60036   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60037   arg2 = (Dali::Property::Index)jarg2;
60038   argp3 = (Dali::Property::Value *)jarg3;
60039   if (!argp3) {
60040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60041     return ;
60042   }
60043   arg3 = *argp3;
60044   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60045   if (!darg) {
60046     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60047     return;
60048   }
60049   {
60050     try {
60051       (darg)->OnPropertySet(arg2,arg3);
60052     } catch (std::out_of_range& e) {
60053       {
60054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60055       };
60056     } catch (std::exception& e) {
60057       {
60058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60059       };
60060     } catch (Dali::DaliException e) {
60061       {
60062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60063       };
60064     } catch (...) {
60065       {
60066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60067       };
60068     }
60069   }
60070
60071 }
60072
60073
60074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60075   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60076   Dali::Property::Index arg2 ;
60077   Dali::Property::Value arg3 ;
60078   Dali::Property::Value *argp3 ;
60079   SwigDirector_ViewImpl *darg = 0;
60080
60081   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60082   arg2 = (Dali::Property::Index)jarg2;
60083   argp3 = (Dali::Property::Value *)jarg3;
60084   if (!argp3) {
60085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60086     return ;
60087   }
60088   arg3 = *argp3;
60089   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60090   if (!darg) {
60091     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60092     return;
60093   }
60094   {
60095     try {
60096       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60097     } catch (std::out_of_range& e) {
60098       {
60099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60100       };
60101     } catch (std::exception& e) {
60102       {
60103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60104       };
60105     } catch (Dali::DaliException e) {
60106       {
60107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60108       };
60109     } catch (...) {
60110       {
60111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60112       };
60113     }
60114   }
60115
60116 }
60117
60118
60119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60120   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60121   Dali::Vector3 *arg2 = 0 ;
60122   SwigDirector_ViewImpl *darg = 0;
60123
60124   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60125   arg2 = (Dali::Vector3 *)jarg2;
60126   if (!arg2) {
60127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60128     return ;
60129   }
60130   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60131   if (!darg) {
60132     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60133     return;
60134   }
60135   {
60136     try {
60137       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60138     } catch (std::out_of_range& e) {
60139       {
60140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60141       };
60142     } catch (std::exception& e) {
60143       {
60144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60145       };
60146     } catch (Dali::DaliException e) {
60147       {
60148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60149       };
60150     } catch (...) {
60151       {
60152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60153       };
60154     }
60155   }
60156
60157 }
60158
60159
60160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60161   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60162   Dali::Vector3 *arg2 = 0 ;
60163   SwigDirector_ViewImpl *darg = 0;
60164
60165   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60166   arg2 = (Dali::Vector3 *)jarg2;
60167   if (!arg2) {
60168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60169     return ;
60170   }
60171   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60172   if (!darg) {
60173     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60174     return;
60175   }
60176   {
60177     try {
60178       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60179     } catch (std::out_of_range& e) {
60180       {
60181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60182       };
60183     } catch (std::exception& e) {
60184       {
60185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60186       };
60187     } catch (Dali::DaliException e) {
60188       {
60189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60190       };
60191     } catch (...) {
60192       {
60193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60194       };
60195     }
60196   }
60197
60198 }
60199
60200
60201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60202   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60203   Dali::Animation *arg2 = 0 ;
60204   Dali::Vector3 *arg3 = 0 ;
60205   SwigDirector_ViewImpl *darg = 0;
60206
60207   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60208   arg2 = (Dali::Animation *)jarg2;
60209   if (!arg2) {
60210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60211     return ;
60212   }
60213   arg3 = (Dali::Vector3 *)jarg3;
60214   if (!arg3) {
60215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60216     return ;
60217   }
60218   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60219   if (!darg) {
60220     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60221     return;
60222   }
60223   {
60224     try {
60225       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60226     } catch (std::out_of_range& e) {
60227       {
60228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60229       };
60230     } catch (std::exception& e) {
60231       {
60232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60233       };
60234     } catch (Dali::DaliException e) {
60235       {
60236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60237       };
60238     } catch (...) {
60239       {
60240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60241       };
60242     }
60243   }
60244
60245 }
60246
60247
60248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60249   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60250   Dali::Animation *arg2 = 0 ;
60251   Dali::Vector3 *arg3 = 0 ;
60252   SwigDirector_ViewImpl *darg = 0;
60253
60254   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60255   arg2 = (Dali::Animation *)jarg2;
60256   if (!arg2) {
60257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60258     return ;
60259   }
60260   arg3 = (Dali::Vector3 *)jarg3;
60261   if (!arg3) {
60262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60263     return ;
60264   }
60265   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60266   if (!darg) {
60267     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60268     return;
60269   }
60270   {
60271     try {
60272       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60273     } catch (std::out_of_range& e) {
60274       {
60275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60276       };
60277     } catch (std::exception& e) {
60278       {
60279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60280       };
60281     } catch (Dali::DaliException e) {
60282       {
60283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60284       };
60285     } catch (...) {
60286       {
60287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60288       };
60289     }
60290   }
60291 }
60292
60293
60294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60295   unsigned int jresult ;
60296   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60297   Dali::HoverEvent *arg2 = 0 ;
60298   SwigDirector_ViewImpl *darg = 0;
60299   bool result;
60300
60301   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60302   arg2 = (Dali::HoverEvent *)jarg2;
60303   if (!arg2) {
60304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60305     return 0;
60306   }
60307   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60308   if (!darg) {
60309     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60310     return 0;
60311   }
60312   {
60313     try {
60314       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60315     } catch (std::out_of_range& e) {
60316       {
60317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60318       };
60319     } catch (std::exception& e) {
60320       {
60321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60322       };
60323     } catch (Dali::DaliException e) {
60324       {
60325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60326       };
60327     } catch (...) {
60328       {
60329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60330       };
60331     }
60332   }
60333
60334   jresult = result;
60335   return jresult;
60336 }
60337
60338
60339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60340   unsigned int jresult ;
60341   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60342   Dali::HoverEvent *arg2 = 0 ;
60343   SwigDirector_ViewImpl *darg = 0;
60344   bool result;
60345
60346   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60347   arg2 = (Dali::HoverEvent *)jarg2;
60348   if (!arg2) {
60349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60350     return 0;
60351   }
60352   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60353   if (!darg) {
60354     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60355     return 0;
60356   }
60357   {
60358     try {
60359       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60360     } catch (std::out_of_range& e) {
60361       {
60362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60363       };
60364     } catch (std::exception& e) {
60365       {
60366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60367       };
60368     } catch (Dali::DaliException e) {
60369       {
60370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60371       };
60372     } catch (...) {
60373       {
60374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60375       };
60376     }
60377   }
60378
60379   jresult = result;
60380   return jresult;
60381 }
60382
60383
60384 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60385   unsigned int jresult ;
60386   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60387   Dali::KeyEvent *arg2 = 0 ;
60388   SwigDirector_ViewImpl *darg = 0;
60389   bool result;
60390
60391   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60392   arg2 = (Dali::KeyEvent *)jarg2;
60393   if (!arg2) {
60394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60395     return 0;
60396   }
60397   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60398   if (!darg) {
60399     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60400     return 0;
60401   }
60402   {
60403     try {
60404       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60405     } catch (std::out_of_range& e) {
60406       {
60407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60408       };
60409     } catch (std::exception& e) {
60410       {
60411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60412       };
60413     } catch (Dali::DaliException e) {
60414       {
60415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60416       };
60417     } catch (...) {
60418       {
60419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60420       };
60421     }
60422   }
60423
60424   jresult = result;
60425   return jresult;
60426 }
60427
60428
60429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60430   unsigned int jresult ;
60431   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60432   Dali::KeyEvent *arg2 = 0 ;
60433   SwigDirector_ViewImpl *darg = 0;
60434   bool result;
60435
60436   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60437   arg2 = (Dali::KeyEvent *)jarg2;
60438   if (!arg2) {
60439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60440     return 0;
60441   }
60442   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60443   if (!darg) {
60444     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60445     return 0;
60446   }
60447   {
60448     try {
60449       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60450     } catch (std::out_of_range& e) {
60451       {
60452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60453       };
60454     } catch (std::exception& e) {
60455       {
60456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60457       };
60458     } catch (Dali::DaliException e) {
60459       {
60460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60461       };
60462     } catch (...) {
60463       {
60464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60465       };
60466     }
60467   }
60468
60469   jresult = result;
60470   return jresult;
60471 }
60472
60473
60474 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60475   unsigned int jresult ;
60476   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60477   Dali::WheelEvent *arg2 = 0 ;
60478   SwigDirector_ViewImpl *darg = 0;
60479   bool result;
60480
60481   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60482   arg2 = (Dali::WheelEvent *)jarg2;
60483   if (!arg2) {
60484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60485     return 0;
60486   }
60487   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60488   if (!darg) {
60489     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60490     return 0;
60491   }
60492   {
60493     try {
60494       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
60495     } catch (std::out_of_range& e) {
60496       {
60497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60498       };
60499     } catch (std::exception& e) {
60500       {
60501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60502       };
60503     } catch (Dali::DaliException e) {
60504       {
60505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60506       };
60507     } catch (...) {
60508       {
60509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60510       };
60511     }
60512   }
60513
60514   jresult = result;
60515   return jresult;
60516 }
60517
60518
60519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60520   unsigned int jresult ;
60521   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60522   Dali::WheelEvent *arg2 = 0 ;
60523   SwigDirector_ViewImpl *darg = 0;
60524   bool result;
60525
60526   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60527   arg2 = (Dali::WheelEvent *)jarg2;
60528   if (!arg2) {
60529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60530     return 0;
60531   }
60532   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60533   if (!darg) {
60534     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60535     return 0;
60536   }
60537   {
60538     try {
60539       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
60540     } catch (std::out_of_range& e) {
60541       {
60542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60543       };
60544     } catch (std::exception& e) {
60545       {
60546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60547       };
60548     } catch (Dali::DaliException e) {
60549       {
60550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60551       };
60552     } catch (...) {
60553       {
60554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60555       };
60556     }
60557   }
60558
60559   jresult = result;
60560   return jresult;
60561 }
60562
60563
60564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
60565   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60566   Dali::Vector2 *arg2 = 0 ;
60567   Dali::RelayoutContainer *arg3 = 0 ;
60568   SwigDirector_ViewImpl *darg = 0;
60569
60570   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60571   arg2 = (Dali::Vector2 *)jarg2;
60572   if (!arg2) {
60573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60574     return ;
60575   }
60576   arg3 = (Dali::RelayoutContainer *)jarg3;
60577   if (!arg3) {
60578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60579     return ;
60580   }
60581   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60582   if (!darg) {
60583     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60584     return;
60585   }
60586   {
60587     try {
60588       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
60589     } catch (std::out_of_range& e) {
60590       {
60591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60592       };
60593     } catch (std::exception& e) {
60594       {
60595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60596       };
60597     } catch (Dali::DaliException e) {
60598       {
60599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60600       };
60601     } catch (...) {
60602       {
60603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60604       };
60605     }
60606   }
60607
60608 }
60609
60610
60611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60612   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60613   Dali::Vector2 *arg2 = 0 ;
60614   Dali::RelayoutContainer *arg3 = 0 ;
60615   SwigDirector_ViewImpl *darg = 0;
60616
60617   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60618   arg2 = (Dali::Vector2 *)jarg2;
60619   if (!arg2) {
60620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60621     return ;
60622   }
60623   arg3 = (Dali::RelayoutContainer *)jarg3;
60624   if (!arg3) {
60625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60626     return ;
60627   }
60628   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60629   if (!darg) {
60630     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60631     return;
60632   }
60633   {
60634     try {
60635       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
60636     } catch (std::out_of_range& e) {
60637       {
60638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60639       };
60640     } catch (std::exception& e) {
60641       {
60642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60643       };
60644     } catch (Dali::DaliException e) {
60645       {
60646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60647       };
60648     } catch (...) {
60649       {
60650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60651       };
60652     }
60653   }
60654
60655 }
60656
60657
60658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
60659   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60660   Dali::ResizePolicy::Type arg2 ;
60661   Dali::Dimension::Type arg3 ;
60662   SwigDirector_ViewImpl *darg = 0;
60663
60664   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60665   arg2 = (Dali::ResizePolicy::Type)jarg2;
60666   arg3 = (Dali::Dimension::Type)jarg3;
60667   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60668   if (!darg) {
60669     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60670     return;
60671   }
60672   {
60673     try {
60674       (darg)->OnSetResizePolicy(arg2,arg3);
60675     } catch (std::out_of_range& e) {
60676       {
60677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60678       };
60679     } catch (std::exception& e) {
60680       {
60681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60682       };
60683     } catch (Dali::DaliException e) {
60684       {
60685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60686       };
60687     } catch (...) {
60688       {
60689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60690       };
60691     }
60692   }
60693
60694 }
60695
60696
60697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
60698   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60699   Dali::ResizePolicy::Type arg2 ;
60700   Dali::Dimension::Type arg3 ;
60701   SwigDirector_ViewImpl *darg = 0;
60702
60703   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60704   arg2 = (Dali::ResizePolicy::Type)jarg2;
60705   arg3 = (Dali::Dimension::Type)jarg3;
60706   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60707   if (!darg) {
60708     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60709     return;
60710   }
60711   {
60712     try {
60713       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
60714     } catch (std::out_of_range& e) {
60715       {
60716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60717       };
60718     } catch (std::exception& e) {
60719       {
60720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60721       };
60722     } catch (Dali::DaliException e) {
60723       {
60724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60725       };
60726     } catch (...) {
60727       {
60728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60729       };
60730     }
60731   }
60732
60733 }
60734
60735
60736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
60737   void * jresult ;
60738   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60739   SwigDirector_ViewImpl *darg = 0;
60740   Dali::Vector3 result;
60741
60742   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60743   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60744   if (!darg) {
60745     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60746     return 0;
60747   }
60748   {
60749     try {
60750       result = (darg)->GetNaturalSize();
60751     } catch (std::out_of_range& e) {
60752       {
60753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60754       };
60755     } catch (std::exception& e) {
60756       {
60757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60758       };
60759     } catch (Dali::DaliException e) {
60760       {
60761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60762       };
60763     } catch (...) {
60764       {
60765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60766       };
60767     }
60768   }
60769
60770   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60771   return jresult;
60772 }
60773
60774
60775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
60776   void * jresult ;
60777   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60778   SwigDirector_ViewImpl *darg = 0;
60779   Dali::Vector3 result;
60780
60781   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60782   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60783   if (!darg) {
60784     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60785     return 0;
60786   }
60787   {
60788     try {
60789       result = (darg)->GetNaturalSizeSwigPublic();
60790     } catch (std::out_of_range& e) {
60791       {
60792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60793       };
60794     } catch (std::exception& e) {
60795       {
60796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60797       };
60798     } catch (Dali::DaliException e) {
60799       {
60800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60801       };
60802     } catch (...) {
60803       {
60804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60805       };
60806     }
60807   }
60808
60809   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60810   return jresult;
60811 }
60812
60813
60814 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
60815   float jresult ;
60816   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60817   Dali::Actor *arg2 = 0 ;
60818   Dali::Dimension::Type arg3 ;
60819   SwigDirector_ViewImpl *darg = 0;
60820   float result;
60821
60822   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60823   arg2 = (Dali::Actor *)jarg2;
60824   if (!arg2) {
60825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60826     return 0;
60827   }
60828   arg3 = (Dali::Dimension::Type)jarg3;
60829   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60830   if (!darg) {
60831     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60832     return 0;
60833   }
60834   {
60835     try {
60836       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
60837     } catch (std::out_of_range& e) {
60838       {
60839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60840       };
60841     } catch (std::exception& e) {
60842       {
60843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60844       };
60845     } catch (Dali::DaliException e) {
60846       {
60847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60848       };
60849     } catch (...) {
60850       {
60851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60852       };
60853     }
60854   }
60855
60856   jresult = result;
60857   return jresult;
60858 }
60859
60860
60861 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
60862   float jresult ;
60863   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60864   Dali::Actor *arg2 = 0 ;
60865   Dali::Dimension::Type arg3 ;
60866   SwigDirector_ViewImpl *darg = 0;
60867   float result;
60868
60869   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60870   arg2 = (Dali::Actor *)jarg2;
60871   if (!arg2) {
60872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60873     return 0;
60874   }
60875   arg3 = (Dali::Dimension::Type)jarg3;
60876   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60877   if (!darg) {
60878     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60879     return 0;
60880   }
60881   {
60882     try {
60883       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
60884     } catch (std::out_of_range& e) {
60885       {
60886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60887       };
60888     } catch (std::exception& e) {
60889       {
60890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60891       };
60892     } catch (Dali::DaliException e) {
60893       {
60894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60895       };
60896     } catch (...) {
60897       {
60898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60899       };
60900     }
60901   }
60902
60903   jresult = result;
60904   return jresult;
60905 }
60906
60907
60908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
60909   float jresult ;
60910   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60911   float arg2 ;
60912   SwigDirector_ViewImpl *darg = 0;
60913   float result;
60914
60915   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60916   arg2 = (float)jarg2;
60917   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60918   if (!darg) {
60919     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60920     return 0;
60921   }
60922   {
60923     try {
60924       result = (float)(darg)->GetHeightForWidth(arg2);
60925     } catch (std::out_of_range& e) {
60926       {
60927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60928       };
60929     } catch (std::exception& e) {
60930       {
60931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60932       };
60933     } catch (Dali::DaliException e) {
60934       {
60935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60936       };
60937     } catch (...) {
60938       {
60939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60940       };
60941     }
60942   }
60943
60944   jresult = result;
60945   return jresult;
60946 }
60947
60948
60949 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
60950   float jresult ;
60951   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60952   float arg2 ;
60953   SwigDirector_ViewImpl *darg = 0;
60954   float result;
60955
60956   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60957   arg2 = (float)jarg2;
60958   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60959   if (!darg) {
60960     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60961     return 0;
60962   }
60963   {
60964     try {
60965       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
60966     } catch (std::out_of_range& e) {
60967       {
60968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60969       };
60970     } catch (std::exception& e) {
60971       {
60972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60973       };
60974     } catch (Dali::DaliException e) {
60975       {
60976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60977       };
60978     } catch (...) {
60979       {
60980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60981       };
60982     }
60983   }
60984
60985   jresult = result;
60986   return jresult;
60987 }
60988
60989
60990 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
60991   float jresult ;
60992   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60993   float arg2 ;
60994   SwigDirector_ViewImpl *darg = 0;
60995   float result;
60996
60997   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60998   arg2 = (float)jarg2;
60999   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61000   if (!darg) {
61001     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61002     return 0;
61003   }
61004   {
61005     try {
61006       result = (float)(darg)->GetWidthForHeight(arg2);
61007     } catch (std::out_of_range& e) {
61008       {
61009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61010       };
61011     } catch (std::exception& e) {
61012       {
61013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61014       };
61015     } catch (Dali::DaliException e) {
61016       {
61017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61018       };
61019     } catch (...) {
61020       {
61021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61022       };
61023     }
61024   }
61025
61026   jresult = result;
61027   return jresult;
61028 }
61029
61030
61031 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61032   float jresult ;
61033   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61034   float arg2 ;
61035   SwigDirector_ViewImpl *darg = 0;
61036   float result;
61037
61038   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61039   arg2 = (float)jarg2;
61040   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61041   if (!darg) {
61042     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61043     return 0;
61044   }
61045   {
61046     try {
61047       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61048     } catch (std::out_of_range& e) {
61049       {
61050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61051       };
61052     } catch (std::exception& e) {
61053       {
61054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61055       };
61056     } catch (Dali::DaliException e) {
61057       {
61058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61059       };
61060     } catch (...) {
61061       {
61062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61063       };
61064     }
61065   }
61066
61067   jresult = result;
61068   return jresult;
61069 }
61070
61071
61072 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61073   unsigned int jresult ;
61074   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61075   Dali::Dimension::Type arg2 ;
61076   SwigDirector_ViewImpl *darg = 0;
61077   bool result;
61078
61079   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61080   arg2 = (Dali::Dimension::Type)jarg2;
61081   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61082   if (!darg) {
61083     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61084     return 0;
61085   }
61086   {
61087     try {
61088       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61089     } catch (std::out_of_range& e) {
61090       {
61091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61092       };
61093     } catch (std::exception& e) {
61094       {
61095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61096       };
61097     } catch (Dali::DaliException e) {
61098       {
61099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61100       };
61101     } catch (...) {
61102       {
61103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61104       };
61105     }
61106   }
61107
61108   jresult = result;
61109   return jresult;
61110 }
61111
61112
61113 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61114   unsigned int jresult ;
61115   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61116   Dali::Dimension::Type arg2 ;
61117   SwigDirector_ViewImpl *darg = 0;
61118   bool result;
61119
61120   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61121   arg2 = (Dali::Dimension::Type)jarg2;
61122   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61123   if (!darg) {
61124     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61125     return 0;
61126   }
61127   {
61128     try {
61129       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61130     } catch (std::out_of_range& e) {
61131       {
61132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61133       };
61134     } catch (std::exception& e) {
61135       {
61136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61137       };
61138     } catch (Dali::DaliException e) {
61139       {
61140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61141       };
61142     } catch (...) {
61143       {
61144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61145       };
61146     }
61147   }
61148
61149   jresult = result;
61150   return jresult;
61151 }
61152
61153
61154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61155   unsigned int jresult ;
61156   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61157   SwigDirector_ViewImpl *darg = 0;
61158   bool result;
61159
61160   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61161   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61162   if (!darg) {
61163     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61164     return 0;
61165   }
61166   {
61167     try {
61168       result = (bool)(darg)->RelayoutDependentOnChildren();
61169     } catch (std::out_of_range& e) {
61170       {
61171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61172       };
61173     } catch (std::exception& e) {
61174       {
61175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61176       };
61177     } catch (Dali::DaliException e) {
61178       {
61179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61180       };
61181     } catch (...) {
61182       {
61183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61184       };
61185     }
61186   }
61187
61188   jresult = result;
61189   return jresult;
61190 }
61191
61192
61193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61194   unsigned int jresult ;
61195   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61196   SwigDirector_ViewImpl *darg = 0;
61197   bool result;
61198
61199   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61200   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61201   if (!darg) {
61202     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61203     return 0;
61204   }
61205   {
61206     try {
61207       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61208     } catch (std::out_of_range& e) {
61209       {
61210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61211       };
61212     } catch (std::exception& e) {
61213       {
61214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61215       };
61216     } catch (Dali::DaliException e) {
61217       {
61218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61219       };
61220     } catch (...) {
61221       {
61222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61223       };
61224     }
61225   }
61226
61227   jresult = result;
61228   return jresult;
61229 }
61230
61231
61232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61233   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61234   Dali::Dimension::Type arg2 ;
61235   SwigDirector_ViewImpl *darg = 0;
61236
61237   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61238   arg2 = (Dali::Dimension::Type)jarg2;
61239   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61240   if (!darg) {
61241     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61242     return;
61243   }
61244   {
61245     try {
61246       (darg)->OnCalculateRelayoutSize(arg2);
61247     } catch (std::out_of_range& e) {
61248       {
61249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61250       };
61251     } catch (std::exception& e) {
61252       {
61253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61254       };
61255     } catch (Dali::DaliException e) {
61256       {
61257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61258       };
61259     } catch (...) {
61260       {
61261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61262       };
61263     }
61264   }
61265
61266 }
61267
61268
61269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61270   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61271   Dali::Dimension::Type arg2 ;
61272   SwigDirector_ViewImpl *darg = 0;
61273
61274   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61275   arg2 = (Dali::Dimension::Type)jarg2;
61276   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61277   if (!darg) {
61278     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61279     return;
61280   }
61281   {
61282     try {
61283       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61284     } catch (std::out_of_range& e) {
61285       {
61286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61287       };
61288     } catch (std::exception& e) {
61289       {
61290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61291       };
61292     } catch (Dali::DaliException e) {
61293       {
61294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61295       };
61296     } catch (...) {
61297       {
61298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61299       };
61300     }
61301   }
61302
61303 }
61304
61305
61306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61307   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61308   float arg2 ;
61309   Dali::Dimension::Type arg3 ;
61310   SwigDirector_ViewImpl *darg = 0;
61311
61312   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61313   arg2 = (float)jarg2;
61314   arg3 = (Dali::Dimension::Type)jarg3;
61315   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61316   if (!darg) {
61317     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61318     return;
61319   }
61320   {
61321     try {
61322       (darg)->OnLayoutNegotiated(arg2,arg3);
61323     } catch (std::out_of_range& e) {
61324       {
61325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61326       };
61327     } catch (std::exception& e) {
61328       {
61329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61330       };
61331     } catch (Dali::DaliException e) {
61332       {
61333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61334       };
61335     } catch (...) {
61336       {
61337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61338       };
61339     }
61340   }
61341
61342 }
61343
61344
61345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61346   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61347   float arg2 ;
61348   Dali::Dimension::Type arg3 ;
61349   SwigDirector_ViewImpl *darg = 0;
61350
61351   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61352   arg2 = (float)jarg2;
61353   arg3 = (Dali::Dimension::Type)jarg3;
61354   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61355   if (!darg) {
61356     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61357     return;
61358   }
61359   {
61360     try {
61361       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61362     } catch (std::out_of_range& e) {
61363       {
61364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61365       };
61366     } catch (std::exception& e) {
61367       {
61368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61369       };
61370     } catch (Dali::DaliException e) {
61371       {
61372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61373       };
61374     } catch (...) {
61375       {
61376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61377       };
61378     }
61379   }
61380
61381 }
61382
61383
61384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
61385   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61386
61387   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61388   {
61389     try {
61390       (arg1)->OnInitialize();
61391     } catch (std::out_of_range& e) {
61392       {
61393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61394       };
61395     } catch (std::exception& e) {
61396       {
61397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61398       };
61399     } catch (Dali::DaliException e) {
61400       {
61401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61402       };
61403     } catch (...) {
61404       {
61405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61406       };
61407     }
61408   }
61409
61410 }
61411
61412
61413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61414   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61415
61416   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61417   {
61418     try {
61419       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61420     } catch (std::out_of_range& e) {
61421       {
61422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61423       };
61424     } catch (std::exception& e) {
61425       {
61426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61427       };
61428     } catch (Dali::DaliException e) {
61429       {
61430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61431       };
61432     } catch (...) {
61433       {
61434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61435       };
61436     }
61437   }
61438
61439 }
61440
61441
61442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61443   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61444   Dali::Toolkit::StyleManager arg2 ;
61445   Dali::StyleChange::Type arg3 ;
61446   Dali::Toolkit::StyleManager *argp2 ;
61447
61448   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61449   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61450   if (!argp2) {
61451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61452     return ;
61453   }
61454   arg2 = *argp2;
61455   arg3 = (Dali::StyleChange::Type)jarg3;
61456   {
61457     try {
61458       (arg1)->OnStyleChange(arg2,arg3);
61459     } catch (std::out_of_range& e) {
61460       {
61461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61462       };
61463     } catch (std::exception& e) {
61464       {
61465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61466       };
61467     } catch (Dali::DaliException e) {
61468       {
61469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61470       };
61471     } catch (...) {
61472       {
61473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61474       };
61475     }
61476   }
61477
61478 }
61479
61480
61481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61482   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61483   Dali::Toolkit::StyleManager arg2 ;
61484   Dali::StyleChange::Type arg3 ;
61485   Dali::Toolkit::StyleManager *argp2 ;
61486
61487   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61488   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61489   if (!argp2) {
61490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61491     return ;
61492   }
61493   arg2 = *argp2;
61494   arg3 = (Dali::StyleChange::Type)jarg3;
61495   {
61496     try {
61497       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61498     } catch (std::out_of_range& e) {
61499       {
61500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61501       };
61502     } catch (std::exception& e) {
61503       {
61504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61505       };
61506     } catch (Dali::DaliException e) {
61507       {
61508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61509       };
61510     } catch (...) {
61511       {
61512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61513       };
61514     }
61515   }
61516
61517 }
61518
61519
61520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
61521   unsigned int jresult ;
61522   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61523   bool result;
61524
61525   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61526   {
61527     try {
61528       result = (bool)(arg1)->OnAccessibilityActivated();
61529     } catch (std::out_of_range& e) {
61530       {
61531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61532       };
61533     } catch (std::exception& e) {
61534       {
61535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61536       };
61537     } catch (Dali::DaliException e) {
61538       {
61539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61540       };
61541     } catch (...) {
61542       {
61543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61544       };
61545     }
61546   }
61547
61548   jresult = result;
61549   return jresult;
61550 }
61551
61552
61553 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
61554   unsigned int jresult ;
61555   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61556   bool result;
61557
61558   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61559   {
61560     try {
61561       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
61562     } catch (std::out_of_range& e) {
61563       {
61564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61565       };
61566     } catch (std::exception& e) {
61567       {
61568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61569       };
61570     } catch (Dali::DaliException e) {
61571       {
61572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61573       };
61574     } catch (...) {
61575       {
61576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61577       };
61578     }
61579   }
61580
61581   jresult = result;
61582   return jresult;
61583 }
61584
61585
61586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
61587   unsigned int jresult ;
61588   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61589   Dali::PanGesture arg2 ;
61590   Dali::PanGesture *argp2 ;
61591   bool result;
61592
61593   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61594   argp2 = (Dali::PanGesture *)jarg2;
61595   if (!argp2) {
61596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61597     return 0;
61598   }
61599   arg2 = *argp2;
61600   {
61601     try {
61602       result = (bool)(arg1)->OnAccessibilityPan(arg2);
61603     } catch (std::out_of_range& e) {
61604       {
61605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61606       };
61607     } catch (std::exception& e) {
61608       {
61609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61610       };
61611     } catch (Dali::DaliException e) {
61612       {
61613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61614       };
61615     } catch (...) {
61616       {
61617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61618       };
61619     }
61620   }
61621
61622   jresult = result;
61623   return jresult;
61624 }
61625
61626
61627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61628   unsigned int jresult ;
61629   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61630   Dali::PanGesture arg2 ;
61631   Dali::PanGesture *argp2 ;
61632   bool result;
61633
61634   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61635   argp2 = (Dali::PanGesture *)jarg2;
61636   if (!argp2) {
61637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61638     return 0;
61639   }
61640   arg2 = *argp2;
61641   {
61642     try {
61643       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
61644     } catch (std::out_of_range& e) {
61645       {
61646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61647       };
61648     } catch (std::exception& e) {
61649       {
61650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61651       };
61652     } catch (Dali::DaliException e) {
61653       {
61654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61655       };
61656     } catch (...) {
61657       {
61658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61659       };
61660     }
61661   }
61662
61663   jresult = result;
61664   return jresult;
61665 }
61666
61667
61668
61669
61670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
61671   unsigned int jresult ;
61672   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61673   bool arg2 ;
61674   bool result;
61675
61676   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61677   arg2 = jarg2 ? true : false;
61678   {
61679     try {
61680       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
61681     } catch (std::out_of_range& e) {
61682       {
61683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61684       };
61685     } catch (std::exception& e) {
61686       {
61687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61688       };
61689     } catch (Dali::DaliException e) {
61690       {
61691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61692       };
61693     } catch (...) {
61694       {
61695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61696       };
61697     }
61698   }
61699
61700   jresult = result;
61701   return jresult;
61702 }
61703
61704
61705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
61706   unsigned int jresult ;
61707   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61708   bool arg2 ;
61709   bool result;
61710
61711   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61712   arg2 = jarg2 ? true : false;
61713   {
61714     try {
61715       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
61716     } catch (std::out_of_range& e) {
61717       {
61718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61719       };
61720     } catch (std::exception& e) {
61721       {
61722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61723       };
61724     } catch (Dali::DaliException e) {
61725       {
61726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61727       };
61728     } catch (...) {
61729       {
61730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61731       };
61732     }
61733   }
61734
61735   jresult = result;
61736   return jresult;
61737 }
61738
61739
61740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
61741   unsigned int jresult ;
61742   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61743   bool result;
61744
61745   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61746   {
61747     try {
61748       result = (bool)(arg1)->OnAccessibilityZoom();
61749     } catch (std::out_of_range& e) {
61750       {
61751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61752       };
61753     } catch (std::exception& e) {
61754       {
61755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61756       };
61757     } catch (Dali::DaliException e) {
61758       {
61759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61760       };
61761     } catch (...) {
61762       {
61763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61764       };
61765     }
61766   }
61767
61768   jresult = result;
61769   return jresult;
61770 }
61771
61772
61773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
61774   unsigned int jresult ;
61775   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61776   bool result;
61777
61778   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61779   {
61780     try {
61781       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
61782     } catch (std::out_of_range& e) {
61783       {
61784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61785       };
61786     } catch (std::exception& e) {
61787       {
61788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61789       };
61790     } catch (Dali::DaliException e) {
61791       {
61792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61793       };
61794     } catch (...) {
61795       {
61796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61797       };
61798     }
61799   }
61800
61801   jresult = result;
61802   return jresult;
61803 }
61804
61805
61806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
61807   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61808
61809   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61810   {
61811     try {
61812       (arg1)->OnKeyInputFocusGained();
61813     } catch (std::out_of_range& e) {
61814       {
61815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61816       };
61817     } catch (std::exception& e) {
61818       {
61819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61820       };
61821     } catch (Dali::DaliException e) {
61822       {
61823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61824       };
61825     } catch (...) {
61826       {
61827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61828       };
61829     }
61830   }
61831
61832 }
61833
61834
61835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
61836   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61837
61838   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61839   {
61840     try {
61841       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
61842     } catch (std::out_of_range& e) {
61843       {
61844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61845       };
61846     } catch (std::exception& e) {
61847       {
61848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61849       };
61850     } catch (Dali::DaliException e) {
61851       {
61852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61853       };
61854     } catch (...) {
61855       {
61856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61857       };
61858     }
61859   }
61860
61861 }
61862
61863
61864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
61865   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61866
61867   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61868   {
61869     try {
61870       (arg1)->OnKeyInputFocusLost();
61871     } catch (std::out_of_range& e) {
61872       {
61873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61874       };
61875     } catch (std::exception& e) {
61876       {
61877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61878       };
61879     } catch (Dali::DaliException e) {
61880       {
61881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61882       };
61883     } catch (...) {
61884       {
61885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61886       };
61887     }
61888   }
61889
61890 }
61891
61892
61893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
61894   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61895
61896   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61897   {
61898     try {
61899       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
61900     } catch (std::out_of_range& e) {
61901       {
61902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61903       };
61904     } catch (std::exception& e) {
61905       {
61906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61907       };
61908     } catch (Dali::DaliException e) {
61909       {
61910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61911       };
61912     } catch (...) {
61913       {
61914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61915       };
61916     }
61917   }
61918
61919 }
61920
61921
61922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61923   void * jresult ;
61924   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61925   Dali::Actor arg2 ;
61926   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61927   bool arg4 ;
61928   Dali::Actor *argp2 ;
61929   Dali::Actor result;
61930
61931   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61932   argp2 = (Dali::Actor *)jarg2;
61933   if (!argp2) {
61934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61935     return 0;
61936   }
61937   arg2 = *argp2;
61938   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61939   arg4 = jarg4 ? true : false;
61940   {
61941     try {
61942       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61943     } catch (std::out_of_range& e) {
61944       {
61945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61946       };
61947     } catch (std::exception& e) {
61948       {
61949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61950       };
61951     } catch (Dali::DaliException e) {
61952       {
61953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61954       };
61955     } catch (...) {
61956       {
61957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61958       };
61959     }
61960   }
61961
61962   jresult = new Dali::Actor((const Dali::Actor &)result);
61963   return jresult;
61964 }
61965
61966
61967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
61968   void * jresult ;
61969   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61970   Dali::Actor arg2 ;
61971   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
61972   bool arg4 ;
61973   Dali::Actor *argp2 ;
61974   Dali::Actor result;
61975
61976   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61977   argp2 = (Dali::Actor *)jarg2;
61978   if (!argp2) {
61979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61980     return 0;
61981   }
61982   arg2 = *argp2;
61983   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
61984   arg4 = jarg4 ? true : false;
61985   {
61986     try {
61987       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
61988     } catch (std::out_of_range& e) {
61989       {
61990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61991       };
61992     } catch (std::exception& e) {
61993       {
61994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61995       };
61996     } catch (Dali::DaliException e) {
61997       {
61998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61999       };
62000     } catch (...) {
62001       {
62002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62003       };
62004     }
62005   }
62006
62007   jresult = new Dali::Actor((const Dali::Actor &)result);
62008   return jresult;
62009 }
62010
62011
62012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62013   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62014   Dali::Actor arg2 ;
62015   Dali::Actor *argp2 ;
62016
62017   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62018   argp2 = (Dali::Actor *)jarg2;
62019   if (!argp2) {
62020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62021     return ;
62022   }
62023   arg2 = *argp2;
62024   {
62025     try {
62026       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62027     } catch (std::out_of_range& e) {
62028       {
62029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62030       };
62031     } catch (std::exception& e) {
62032       {
62033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62034       };
62035     } catch (Dali::DaliException e) {
62036       {
62037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62038       };
62039     } catch (...) {
62040       {
62041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62042       };
62043     }
62044   }
62045
62046 }
62047
62048
62049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62050   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62051   Dali::Actor arg2 ;
62052   Dali::Actor *argp2 ;
62053
62054   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62055   argp2 = (Dali::Actor *)jarg2;
62056   if (!argp2) {
62057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62058     return ;
62059   }
62060   arg2 = *argp2;
62061   {
62062     try {
62063       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62064     } catch (std::out_of_range& e) {
62065       {
62066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62067       };
62068     } catch (std::exception& e) {
62069       {
62070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62071       };
62072     } catch (Dali::DaliException e) {
62073       {
62074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62075       };
62076     } catch (...) {
62077       {
62078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62079       };
62080     }
62081   }
62082
62083 }
62084
62085
62086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62087   unsigned int jresult ;
62088   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62089   bool result;
62090
62091   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62092   {
62093     try {
62094       result = (bool)(arg1)->OnKeyboardEnter();
62095     } catch (std::out_of_range& e) {
62096       {
62097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62098       };
62099     } catch (std::exception& e) {
62100       {
62101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62102       };
62103     } catch (Dali::DaliException e) {
62104       {
62105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62106       };
62107     } catch (...) {
62108       {
62109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62110       };
62111     }
62112   }
62113
62114   jresult = result;
62115   return jresult;
62116 }
62117
62118
62119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62120   unsigned int jresult ;
62121   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62122   bool result;
62123
62124   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62125   {
62126     try {
62127       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62128     } catch (std::out_of_range& e) {
62129       {
62130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62131       };
62132     } catch (std::exception& e) {
62133       {
62134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62135       };
62136     } catch (Dali::DaliException e) {
62137       {
62138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62139       };
62140     } catch (...) {
62141       {
62142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62143       };
62144     }
62145   }
62146
62147   jresult = result;
62148   return jresult;
62149 }
62150
62151
62152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62153   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62154   Dali::PinchGesture *arg2 = 0 ;
62155
62156   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62157   arg2 = (Dali::PinchGesture *)jarg2;
62158   if (!arg2) {
62159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62160     return ;
62161   }
62162   {
62163     try {
62164       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62165     } catch (std::out_of_range& e) {
62166       {
62167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62168       };
62169     } catch (std::exception& e) {
62170       {
62171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62172       };
62173     } catch (Dali::DaliException e) {
62174       {
62175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62176       };
62177     } catch (...) {
62178       {
62179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62180       };
62181     }
62182   }
62183
62184 }
62185
62186
62187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62188   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62189   Dali::PinchGesture *arg2 = 0 ;
62190
62191   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62192   arg2 = (Dali::PinchGesture *)jarg2;
62193   if (!arg2) {
62194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62195     return ;
62196   }
62197   {
62198     try {
62199       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62200     } catch (std::out_of_range& e) {
62201       {
62202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62203       };
62204     } catch (std::exception& e) {
62205       {
62206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62207       };
62208     } catch (Dali::DaliException e) {
62209       {
62210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62211       };
62212     } catch (...) {
62213       {
62214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62215       };
62216     }
62217   }
62218
62219 }
62220
62221
62222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62223   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62224   Dali::PanGesture *arg2 = 0 ;
62225
62226   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62227   arg2 = (Dali::PanGesture *)jarg2;
62228   if (!arg2) {
62229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62230     return ;
62231   }
62232   {
62233     try {
62234       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62235     } catch (std::out_of_range& e) {
62236       {
62237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62238       };
62239     } catch (std::exception& e) {
62240       {
62241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62242       };
62243     } catch (Dali::DaliException e) {
62244       {
62245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62246       };
62247     } catch (...) {
62248       {
62249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62250       };
62251     }
62252   }
62253
62254 }
62255
62256
62257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62258   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62259   Dali::PanGesture *arg2 = 0 ;
62260
62261   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62262   arg2 = (Dali::PanGesture *)jarg2;
62263   if (!arg2) {
62264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62265     return ;
62266   }
62267   {
62268     try {
62269       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62270     } catch (std::out_of_range& e) {
62271       {
62272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62273       };
62274     } catch (std::exception& e) {
62275       {
62276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62277       };
62278     } catch (Dali::DaliException e) {
62279       {
62280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62281       };
62282     } catch (...) {
62283       {
62284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62285       };
62286     }
62287   }
62288
62289 }
62290
62291
62292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62293   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62294   Dali::TapGesture *arg2 = 0 ;
62295
62296   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62297   arg2 = (Dali::TapGesture *)jarg2;
62298   if (!arg2) {
62299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62300     return ;
62301   }
62302   {
62303     try {
62304       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62305     } catch (std::out_of_range& e) {
62306       {
62307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62308       };
62309     } catch (std::exception& e) {
62310       {
62311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62312       };
62313     } catch (Dali::DaliException e) {
62314       {
62315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62316       };
62317     } catch (...) {
62318       {
62319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62320       };
62321     }
62322   }
62323
62324 }
62325
62326
62327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62328   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62329   Dali::TapGesture *arg2 = 0 ;
62330
62331   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62332   arg2 = (Dali::TapGesture *)jarg2;
62333   if (!arg2) {
62334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62335     return ;
62336   }
62337   {
62338     try {
62339       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
62340     } catch (std::out_of_range& e) {
62341       {
62342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62343       };
62344     } catch (std::exception& e) {
62345       {
62346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62347       };
62348     } catch (Dali::DaliException e) {
62349       {
62350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62351       };
62352     } catch (...) {
62353       {
62354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62355       };
62356     }
62357   }
62358
62359 }
62360
62361
62362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62363   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62364   Dali::LongPressGesture *arg2 = 0 ;
62365
62366   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62367   arg2 = (Dali::LongPressGesture *)jarg2;
62368   if (!arg2) {
62369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62370     return ;
62371   }
62372   {
62373     try {
62374       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62375     } catch (std::out_of_range& e) {
62376       {
62377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62378       };
62379     } catch (std::exception& e) {
62380       {
62381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62382       };
62383     } catch (Dali::DaliException e) {
62384       {
62385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62386       };
62387     } catch (...) {
62388       {
62389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62390       };
62391     }
62392   }
62393
62394 }
62395
62396
62397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62398   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62399   Dali::LongPressGesture *arg2 = 0 ;
62400
62401   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62402   arg2 = (Dali::LongPressGesture *)jarg2;
62403   if (!arg2) {
62404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62405     return ;
62406   }
62407   {
62408     try {
62409       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62410     } catch (std::out_of_range& e) {
62411       {
62412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62413       };
62414     } catch (std::exception& e) {
62415       {
62416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62417       };
62418     } catch (Dali::DaliException e) {
62419       {
62420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62421       };
62422     } catch (...) {
62423       {
62424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62425       };
62426     }
62427   }
62428
62429 }
62430
62431
62432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62433   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62434   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62435   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62436
62437   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62438   arg2 = (Dali::SlotObserver *)jarg2;
62439   arg3 = (Dali::CallbackBase *)jarg3;
62440   {
62441     try {
62442       (arg1)->SignalConnected(arg2,arg3);
62443     } catch (std::out_of_range& e) {
62444       {
62445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62446       };
62447     } catch (std::exception& e) {
62448       {
62449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62450       };
62451     } catch (Dali::DaliException e) {
62452       {
62453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62454       };
62455     } catch (...) {
62456       {
62457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62458       };
62459     }
62460   }
62461
62462 }
62463
62464
62465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62466   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62467   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62468   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62469
62470   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62471   arg2 = (Dali::SlotObserver *)jarg2;
62472   arg3 = (Dali::CallbackBase *)jarg3;
62473   {
62474     try {
62475       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62476     } catch (std::out_of_range& e) {
62477       {
62478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62479       };
62480     } catch (std::exception& e) {
62481       {
62482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62483       };
62484     } catch (Dali::DaliException e) {
62485       {
62486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62487       };
62488     } catch (...) {
62489       {
62490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62491       };
62492     }
62493   }
62494
62495 }
62496
62497
62498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62499   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62500   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62501   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62502
62503   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62504   arg2 = (Dali::SlotObserver *)jarg2;
62505   arg3 = (Dali::CallbackBase *)jarg3;
62506   {
62507     try {
62508       (arg1)->SignalDisconnected(arg2,arg3);
62509     } catch (std::out_of_range& e) {
62510       {
62511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62512       };
62513     } catch (std::exception& e) {
62514       {
62515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62516       };
62517     } catch (Dali::DaliException e) {
62518       {
62519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62520       };
62521     } catch (...) {
62522       {
62523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62524       };
62525     }
62526   }
62527
62528 }
62529
62530
62531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62532   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62533   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62534   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62535
62536   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62537   arg2 = (Dali::SlotObserver *)jarg2;
62538   arg3 = (Dali::CallbackBase *)jarg3;
62539   {
62540     try {
62541       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62542     } catch (std::out_of_range& e) {
62543       {
62544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62545       };
62546     } catch (std::exception& e) {
62547       {
62548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62549       };
62550     } catch (Dali::DaliException e) {
62551       {
62552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62553       };
62554     } catch (...) {
62555       {
62556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62557       };
62558     }
62559   }
62560
62561 }
62562
62563 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_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_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) {
62564   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62565   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62566   if (director) {
62567     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback8, callback9, callback10, callback11, callback12, callback13, callback14, callback15, callback16, callback17, callback18, callback19, callback20, callback21, callback24, callback25, callback26, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40);
62568   }
62569 }
62570
62571
62572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
62573   void * jresult ;
62574   Dali::Toolkit::Control *arg1 = 0 ;
62575   Dali::Toolkit::Internal::Control *result = 0 ;
62576
62577   arg1 = (Dali::Toolkit::Control *)jarg1;
62578   if (!arg1) {
62579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62580     return 0;
62581   }
62582   {
62583     try {
62584       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62585     } catch (std::out_of_range& e) {
62586       {
62587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62588       };
62589     } catch (std::exception& e) {
62590       {
62591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62592       };
62593     } catch (Dali::DaliException e) {
62594       {
62595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62596       };
62597     } catch (...) {
62598       {
62599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62600       };
62601     }
62602   }
62603
62604   jresult = (void *)result;
62605   return jresult;
62606 }
62607
62608
62609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
62610   int jresult ;
62611   int result;
62612
62613   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
62614   jresult = (int)result;
62615   return jresult;
62616 }
62617
62618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
62619   int jresult ;
62620   int result;
62621
62622   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
62623   jresult = (int)result;
62624   return jresult;
62625 }
62626
62627
62628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
62629   int jresult ;
62630   int result;
62631
62632   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
62633   jresult = (int)result;
62634   return jresult;
62635 }
62636
62637 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
62638   int jresult ;
62639   int result;
62640
62641   result = (int)Dali::Toolkit::Control::Property::MARGIN;
62642   jresult = (int)result;
62643   return jresult;
62644 }
62645
62646
62647 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
62648   int jresult ;
62649   int result;
62650
62651   result = (int)Dali::Toolkit::Control::Property::PADDING;
62652   jresult = (int)result;
62653   return jresult;
62654 }
62655
62656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
62657   int jresult ;
62658   int result;
62659
62660   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
62661   jresult = (int)result;
62662   return jresult;
62663 }
62664
62665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
62666   void * jresult ;
62667   Dali::Toolkit::Control::Property *result = 0 ;
62668
62669   {
62670     try {
62671       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
62672     } catch (std::out_of_range& e) {
62673       {
62674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62675       };
62676     } catch (std::exception& e) {
62677       {
62678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62679       };
62680     } catch (Dali::DaliException e) {
62681       {
62682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62683       };
62684     } catch (...) {
62685       {
62686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62687       };
62688     }
62689   }
62690
62691   jresult = (void *)result;
62692   return jresult;
62693 }
62694
62695
62696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
62697   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
62698
62699   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
62700   {
62701     try {
62702       delete arg1;
62703     } catch (std::out_of_range& e) {
62704       {
62705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62706       };
62707     } catch (std::exception& e) {
62708       {
62709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62710       };
62711     } catch (Dali::DaliException e) {
62712       {
62713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62714       };
62715     } catch (...) {
62716       {
62717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62718       };
62719     }
62720   }
62721
62722 }
62723
62724
62725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
62726   void * jresult ;
62727   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
62728
62729   {
62730     try {
62731       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
62732     } catch (std::out_of_range& e) {
62733       {
62734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62735       };
62736     } catch (std::exception& e) {
62737       {
62738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62739       };
62740     } catch (Dali::DaliException e) {
62741       {
62742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62743       };
62744     } catch (...) {
62745       {
62746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62747       };
62748     }
62749   }
62750
62751   jresult = (void *)result;
62752   return jresult;
62753 }
62754
62755
62756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
62757   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
62758
62759   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
62760   {
62761     try {
62762       delete arg1;
62763     } catch (std::out_of_range& e) {
62764       {
62765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62766       };
62767     } catch (std::exception& e) {
62768       {
62769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62770       };
62771     } catch (Dali::DaliException e) {
62772       {
62773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62774       };
62775     } catch (...) {
62776       {
62777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62778       };
62779     }
62780   }
62781
62782 }
62783
62784
62785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
62786   void * jresult ;
62787   Dali::Toolkit::Control result;
62788
62789   {
62790     try {
62791       result = Dali::Toolkit::Control::New();
62792     } catch (std::out_of_range& e) {
62793       {
62794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62795       };
62796     } catch (std::exception& e) {
62797       {
62798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62799       };
62800     } catch (Dali::DaliException e) {
62801       {
62802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62803       };
62804     } catch (...) {
62805       {
62806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62807       };
62808     }
62809   }
62810
62811   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62812   return jresult;
62813 }
62814
62815
62816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
62817   void * jresult ;
62818   Dali::Toolkit::Control *result = 0 ;
62819
62820   {
62821     try {
62822       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
62823     } catch (std::out_of_range& e) {
62824       {
62825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62826       };
62827     } catch (std::exception& e) {
62828       {
62829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62830       };
62831     } catch (Dali::DaliException e) {
62832       {
62833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62834       };
62835     } catch (...) {
62836       {
62837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62838       };
62839     }
62840   }
62841
62842   jresult = (void *)result;
62843   return jresult;
62844 }
62845
62846
62847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
62848   void * jresult ;
62849   Dali::Toolkit::Control *arg1 = 0 ;
62850   Dali::Toolkit::Control *result = 0 ;
62851
62852   arg1 = (Dali::Toolkit::Control *)jarg1;
62853   if (!arg1) {
62854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62855     return 0;
62856   }
62857   {
62858     try {
62859       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
62860     } catch (std::out_of_range& e) {
62861       {
62862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62863       };
62864     } catch (std::exception& e) {
62865       {
62866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62867       };
62868     } catch (Dali::DaliException e) {
62869       {
62870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62871       };
62872     } catch (...) {
62873       {
62874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62875       };
62876     }
62877   }
62878
62879   jresult = (void *)result;
62880   return jresult;
62881 }
62882
62883
62884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
62885   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62886
62887   arg1 = (Dali::Toolkit::Control *)jarg1;
62888   {
62889     try {
62890       delete arg1;
62891     } catch (std::out_of_range& e) {
62892       {
62893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62894       };
62895     } catch (std::exception& e) {
62896       {
62897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62898       };
62899     } catch (Dali::DaliException e) {
62900       {
62901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62902       };
62903     } catch (...) {
62904       {
62905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62906       };
62907     }
62908   }
62909
62910 }
62911
62912
62913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
62914   void * jresult ;
62915   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62916   Dali::Toolkit::Control *arg2 = 0 ;
62917   Dali::Toolkit::Control *result = 0 ;
62918
62919   arg1 = (Dali::Toolkit::Control *)jarg1;
62920   arg2 = (Dali::Toolkit::Control *)jarg2;
62921   if (!arg2) {
62922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
62923     return 0;
62924   }
62925   {
62926     try {
62927       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
62928     } catch (std::out_of_range& e) {
62929       {
62930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62931       };
62932     } catch (std::exception& e) {
62933       {
62934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62935       };
62936     } catch (Dali::DaliException e) {
62937       {
62938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62939       };
62940     } catch (...) {
62941       {
62942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62943       };
62944     }
62945   }
62946
62947   jresult = (void *)result;
62948   return jresult;
62949 }
62950
62951
62952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
62953   void * jresult ;
62954   Dali::BaseHandle arg1 ;
62955   Dali::BaseHandle *argp1 ;
62956   Dali::Toolkit::Control result;
62957
62958   argp1 = (Dali::BaseHandle *)jarg1;
62959   if (!argp1) {
62960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62961     return 0;
62962   }
62963   arg1 = *argp1;
62964   {
62965     try {
62966       result = Dali::Toolkit::Control::DownCast(arg1);
62967     } catch (std::out_of_range& e) {
62968       {
62969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62970       };
62971     } catch (std::exception& e) {
62972       {
62973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62974       };
62975     } catch (Dali::DaliException e) {
62976       {
62977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62978       };
62979     } catch (...) {
62980       {
62981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62982       };
62983     }
62984   }
62985
62986   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62987   return jresult;
62988 }
62989
62990
62991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
62992   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
62993
62994   arg1 = (Dali::Toolkit::Control *)jarg1;
62995   {
62996     try {
62997       (arg1)->SetKeyInputFocus();
62998     } catch (std::out_of_range& e) {
62999       {
63000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63001       };
63002     } catch (std::exception& e) {
63003       {
63004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63005       };
63006     } catch (Dali::DaliException e) {
63007       {
63008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63009       };
63010     } catch (...) {
63011       {
63012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63013       };
63014     }
63015   }
63016
63017 }
63018
63019
63020 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63021   unsigned int jresult ;
63022   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63023   bool result;
63024
63025   arg1 = (Dali::Toolkit::Control *)jarg1;
63026   {
63027     try {
63028       result = (bool)(arg1)->HasKeyInputFocus();
63029     } catch (std::out_of_range& e) {
63030       {
63031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63032       };
63033     } catch (std::exception& e) {
63034       {
63035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63036       };
63037     } catch (Dali::DaliException e) {
63038       {
63039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63040       };
63041     } catch (...) {
63042       {
63043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63044       };
63045     }
63046   }
63047
63048   jresult = result;
63049   return jresult;
63050 }
63051
63052
63053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63054   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63055
63056   arg1 = (Dali::Toolkit::Control *)jarg1;
63057   {
63058     try {
63059       (arg1)->ClearKeyInputFocus();
63060     } catch (std::out_of_range& e) {
63061       {
63062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63063       };
63064     } catch (std::exception& e) {
63065       {
63066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63067       };
63068     } catch (Dali::DaliException e) {
63069       {
63070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63071       };
63072     } catch (...) {
63073       {
63074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63075       };
63076     }
63077   }
63078
63079 }
63080
63081
63082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63083   void * jresult ;
63084   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63085   Dali::PinchGestureDetector result;
63086
63087   arg1 = (Dali::Toolkit::Control *)jarg1;
63088   {
63089     try {
63090       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63091     } catch (std::out_of_range& e) {
63092       {
63093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63094       };
63095     } catch (std::exception& e) {
63096       {
63097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63098       };
63099     } catch (Dali::DaliException e) {
63100       {
63101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63102       };
63103     } catch (...) {
63104       {
63105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63106       };
63107     }
63108   }
63109
63110   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63111   return jresult;
63112 }
63113
63114
63115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63116   void * jresult ;
63117   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63118   Dali::PanGestureDetector result;
63119
63120   arg1 = (Dali::Toolkit::Control *)jarg1;
63121   {
63122     try {
63123       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63124     } catch (std::out_of_range& e) {
63125       {
63126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63127       };
63128     } catch (std::exception& e) {
63129       {
63130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63131       };
63132     } catch (Dali::DaliException e) {
63133       {
63134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63135       };
63136     } catch (...) {
63137       {
63138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63139       };
63140     }
63141   }
63142
63143   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63144   return jresult;
63145 }
63146
63147
63148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63149   void * jresult ;
63150   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63151   Dali::TapGestureDetector result;
63152
63153   arg1 = (Dali::Toolkit::Control *)jarg1;
63154   {
63155     try {
63156       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63157     } catch (std::out_of_range& e) {
63158       {
63159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63160       };
63161     } catch (std::exception& e) {
63162       {
63163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63164       };
63165     } catch (Dali::DaliException e) {
63166       {
63167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63168       };
63169     } catch (...) {
63170       {
63171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63172       };
63173     }
63174   }
63175
63176   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63177   return jresult;
63178 }
63179
63180
63181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63182   void * jresult ;
63183   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63184   Dali::LongPressGestureDetector result;
63185
63186   arg1 = (Dali::Toolkit::Control *)jarg1;
63187   {
63188     try {
63189       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63190     } catch (std::out_of_range& e) {
63191       {
63192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63193       };
63194     } catch (std::exception& e) {
63195       {
63196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63197       };
63198     } catch (Dali::DaliException e) {
63199       {
63200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63201       };
63202     } catch (...) {
63203       {
63204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63205       };
63206     }
63207   }
63208
63209   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63210   return jresult;
63211 }
63212
63213
63214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63215   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63216   std::string *arg2 = 0 ;
63217
63218   arg1 = (Dali::Toolkit::Control *)jarg1;
63219   if (!jarg2) {
63220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63221     return ;
63222   }
63223   std::string arg2_str(jarg2);
63224   arg2 = &arg2_str;
63225   {
63226     try {
63227       (arg1)->SetStyleName((std::string const &)*arg2);
63228     } catch (std::out_of_range& e) {
63229       {
63230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63231       };
63232     } catch (std::exception& e) {
63233       {
63234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63235       };
63236     } catch (Dali::DaliException e) {
63237       {
63238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63239       };
63240     } catch (...) {
63241       {
63242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63243       };
63244     }
63245   }
63246
63247
63248   //argout typemap for const std::string&
63249
63250 }
63251
63252
63253 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63254   char * jresult ;
63255   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63256   std::string *result = 0 ;
63257
63258   arg1 = (Dali::Toolkit::Control *)jarg1;
63259   {
63260     try {
63261       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63262     } catch (std::out_of_range& e) {
63263       {
63264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63265       };
63266     } catch (std::exception& e) {
63267       {
63268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63269       };
63270     } catch (Dali::DaliException e) {
63271       {
63272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63273       };
63274     } catch (...) {
63275       {
63276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63277       };
63278     }
63279   }
63280
63281   jresult = SWIG_csharp_string_callback(result->c_str());
63282   return jresult;
63283 }
63284
63285
63286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63287   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63288   Dali::Vector4 *arg2 = 0 ;
63289
63290   arg1 = (Dali::Toolkit::Control *)jarg1;
63291   arg2 = (Dali::Vector4 *)jarg2;
63292   if (!arg2) {
63293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63294     return ;
63295   }
63296   {
63297     try {
63298       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63299     } catch (std::out_of_range& e) {
63300       {
63301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63302       };
63303     } catch (std::exception& e) {
63304       {
63305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63306       };
63307     } catch (Dali::DaliException e) {
63308       {
63309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63310       };
63311     } catch (...) {
63312       {
63313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63314       };
63315     }
63316   }
63317
63318 }
63319
63320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
63321   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63322
63323   arg1 = (Dali::Toolkit::Control *)jarg1;
63324   {
63325     try {
63326       (arg1)->ClearBackground();
63327     } catch (std::out_of_range& e) {
63328       {
63329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63330       };
63331     } catch (std::exception& e) {
63332       {
63333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63334       };
63335     } catch (Dali::DaliException e) {
63336       {
63337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63338       };
63339     } catch (...) {
63340       {
63341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63342       };
63343     }
63344   }
63345
63346 }
63347
63348
63349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
63350   void * jresult ;
63351   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63352   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63353
63354   arg1 = (Dali::Toolkit::Control *)jarg1;
63355   {
63356     try {
63357       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63358     } catch (std::out_of_range& e) {
63359       {
63360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63361       };
63362     } catch (std::exception& e) {
63363       {
63364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63365       };
63366     } catch (Dali::DaliException e) {
63367       {
63368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63369       };
63370     } catch (...) {
63371       {
63372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63373       };
63374     }
63375   }
63376
63377   jresult = (void *)result;
63378   return jresult;
63379 }
63380
63381
63382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
63383   void * jresult ;
63384   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63385   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63386
63387   arg1 = (Dali::Toolkit::Control *)jarg1;
63388   {
63389     try {
63390       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63391     } catch (std::out_of_range& e) {
63392       {
63393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63394       };
63395     } catch (std::exception& e) {
63396       {
63397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63398       };
63399     } catch (Dali::DaliException e) {
63400       {
63401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63402       };
63403     } catch (...) {
63404       {
63405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63406       };
63407     }
63408   }
63409
63410   jresult = (void *)result;
63411   return jresult;
63412 }
63413
63414
63415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
63416   void * jresult ;
63417   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63418   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63419
63420   arg1 = (Dali::Toolkit::Control *)jarg1;
63421   {
63422     try {
63423       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63424     } catch (std::out_of_range& e) {
63425       {
63426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63427       };
63428     } catch (std::exception& e) {
63429       {
63430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63431       };
63432     } catch (Dali::DaliException e) {
63433       {
63434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63435       };
63436     } catch (...) {
63437       {
63438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63439       };
63440     }
63441   }
63442
63443   jresult = (void *)result;
63444   return jresult;
63445 }
63446
63447
63448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
63449   void * jresult ;
63450   Dali::Toolkit::Internal::Control *arg1 = 0 ;
63451   Dali::Toolkit::Control *result = 0 ;
63452
63453   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63454   if (!arg1) {
63455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63456     return 0;
63457   }
63458   {
63459     try {
63460       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63461     } catch (std::out_of_range& e) {
63462       {
63463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63464       };
63465     } catch (std::exception& e) {
63466       {
63467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63468       };
63469     } catch (Dali::DaliException e) {
63470       {
63471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63472       };
63473     } catch (...) {
63474       {
63475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63476       };
63477     }
63478   }
63479
63480   jresult = (void *)result;
63481   return jresult;
63482 }
63483
63484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
63485 {
63486   int jresult;
63487   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63488   arg1 = (Dali::Toolkit::Control *)jarg1;
63489
63490   if (!arg1) {
63491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63492     return 0;
63493   }
63494
63495   Dali::Property::Index arg2 = 0 ;
63496   arg2 = (Dali::Property::Index)jarg2;
63497
63498   Toolkit::Visual::ResourceStatus result;
63499   {
63500     try {
63501       result = arg1->GetVisualResourceStatus(arg2);
63502     } catch (std::out_of_range& e) {
63503       {
63504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63505       };
63506     } catch (std::exception& e) {
63507       {
63508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63509       };
63510     } catch (...) {
63511       {
63512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63513       };
63514     }
63515   }
63516   jresult = (int)(result);
63517   return jresult;
63518 }
63519
63520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
63521 {
63522   void * jresult;
63523   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63524   arg1 = (Dali::Toolkit::Control *)jarg1;
63525
63526   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
63527
63528   Dali::Toolkit::TransitionData *arg2 = 0 ;
63529   Dali::Animation result;
63530
63531   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
63532   if (!arg2) {
63533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
63534     return 0;
63535   }
63536   {
63537     try {
63538       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
63539     } catch (std::out_of_range& e) {
63540       {
63541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63542       };
63543     } catch (std::exception& e) {
63544       {
63545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63546       };
63547     } catch (Dali::DaliException e) {
63548       {
63549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63550       };
63551     } catch (...) {
63552       {
63553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63554       };
63555     }
63556   }
63557
63558   jresult = new Dali::Animation((const Dali::Animation &)result);
63559   return jresult;
63560 }
63561
63562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
63563 {
63564   Dali::Toolkit::Control arg1;
63565   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
63566
63567   if (!argp1) {
63568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63569   }
63570   arg1 = *argp1;
63571
63572   Dali::Property::Index arg2 = 0 ;
63573   arg2 = (Dali::Property::Index)jarg2;
63574
63575   Dali::Property::Index arg3 = 0 ;
63576   arg3 = (Dali::Property::Index)jarg3;
63577
63578   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
63579
63580   {
63581     try {
63582       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
63583     } catch (std::out_of_range& e) {
63584       {
63585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63586       };
63587     } catch (std::exception& e) {
63588       {
63589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63590       };
63591     } catch (...) {
63592       {
63593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63594       };
63595     }
63596   }
63597
63598
63599 }
63600
63601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
63602   void * jresult ;
63603   Dali::Toolkit::Control *arg1 = 0 ;
63604   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
63605
63606   arg1 = (Dali::Toolkit::Control *)jarg1;
63607   if (!arg1) {
63608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63609     return 0;
63610   }
63611   {
63612     try {
63613       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
63614     } catch (std::out_of_range& e) {
63615       {
63616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63617       };
63618     } catch (std::exception& e) {
63619       {
63620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63621       };
63622     } catch (Dali::DaliException e) {
63623       {
63624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63625       };
63626     } catch (...) {
63627       {
63628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63629       };
63630     }
63631   }
63632
63633   jresult = (void *)result;
63634   return jresult;
63635 }
63636
63637
63638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
63639   unsigned int jresult ;
63640   Dali::Toolkit::Control *arg1 = 0 ;
63641   bool result;
63642
63643   arg1 = (Dali::Toolkit::Control *)jarg1;
63644   if (!arg1) {
63645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63646     return 0;
63647   }
63648   {
63649     try {
63650       result = (bool)arg1->IsResourceReady();
63651     } catch (std::out_of_range& e) {
63652       {
63653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63654       };
63655     } catch (std::exception& e) {
63656       {
63657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63658       };
63659     } catch (Dali::DaliException e) {
63660       {
63661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63662       };
63663     } catch (...) {
63664       {
63665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63666       };
63667     }
63668   }
63669
63670   jresult = result;
63671   return jresult;
63672 }
63673
63674
63675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
63676   void * jresult ;
63677   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
63678
63679   {
63680     try {
63681       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
63682     } catch (std::out_of_range& e) {
63683       {
63684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63685       };
63686     } catch (std::exception& e) {
63687       {
63688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63689       };
63690     } catch (Dali::DaliException e) {
63691       {
63692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63693       };
63694     } catch (...) {
63695       {
63696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63697       };
63698     }
63699   }
63700
63701   jresult = (void *)result;
63702   return jresult;
63703 }
63704
63705
63706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
63707   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63708
63709   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63710   {
63711     try {
63712       delete arg1;
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
63735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
63736   void * jresult ;
63737   Dali::Toolkit::KeyInputFocusManager result;
63738
63739   {
63740     try {
63741       result = Dali::Toolkit::KeyInputFocusManager::Get();
63742     } catch (std::out_of_range& e) {
63743       {
63744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63745       };
63746     } catch (std::exception& e) {
63747       {
63748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63749       };
63750     } catch (Dali::DaliException e) {
63751       {
63752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63753       };
63754     } catch (...) {
63755       {
63756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63757       };
63758     }
63759   }
63760
63761   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
63762   return jresult;
63763 }
63764
63765
63766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
63767   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63768   Dali::Toolkit::Control arg2 ;
63769   Dali::Toolkit::Control *argp2 ;
63770
63771   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63772   argp2 = (Dali::Toolkit::Control *)jarg2;
63773   if (!argp2) {
63774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63775     return ;
63776   }
63777   arg2 = *argp2;
63778   {
63779     try {
63780       (arg1)->SetFocus(arg2);
63781     } catch (std::out_of_range& e) {
63782       {
63783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63784       };
63785     } catch (std::exception& e) {
63786       {
63787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63788       };
63789     } catch (Dali::DaliException e) {
63790       {
63791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63792       };
63793     } catch (...) {
63794       {
63795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63796       };
63797     }
63798   }
63799
63800 }
63801
63802
63803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
63804   void * jresult ;
63805   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63806   Dali::Toolkit::Control result;
63807
63808   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63809   {
63810     try {
63811       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
63812     } catch (std::out_of_range& e) {
63813       {
63814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63815       };
63816     } catch (std::exception& e) {
63817       {
63818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63819       };
63820     } catch (Dali::DaliException e) {
63821       {
63822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63823       };
63824     } catch (...) {
63825       {
63826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63827       };
63828     }
63829   }
63830
63831   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63832   return jresult;
63833 }
63834
63835
63836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
63837   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63838   Dali::Toolkit::Control arg2 ;
63839   Dali::Toolkit::Control *argp2 ;
63840
63841   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63842   argp2 = (Dali::Toolkit::Control *)jarg2;
63843   if (!argp2) {
63844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63845     return ;
63846   }
63847   arg2 = *argp2;
63848   {
63849     try {
63850       (arg1)->RemoveFocus(arg2);
63851     } catch (std::out_of_range& e) {
63852       {
63853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63854       };
63855     } catch (std::exception& e) {
63856       {
63857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63858       };
63859     } catch (Dali::DaliException e) {
63860       {
63861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63862       };
63863     } catch (...) {
63864       {
63865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63866       };
63867     }
63868   }
63869
63870 }
63871
63872
63873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
63874   void * jresult ;
63875   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63876   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
63877
63878   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63879   {
63880     try {
63881       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
63882     } catch (std::out_of_range& e) {
63883       {
63884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63885       };
63886     } catch (std::exception& e) {
63887       {
63888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63889       };
63890     } catch (Dali::DaliException e) {
63891       {
63892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63893       };
63894     } catch (...) {
63895       {
63896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63897       };
63898     }
63899   }
63900
63901   jresult = (void *)result;
63902   return jresult;
63903 }
63904
63905
63906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
63907   void * jresult ;
63908   Dali::Toolkit::Alignment::Padding *result = 0 ;
63909
63910   {
63911     try {
63912       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
63913     } catch (std::out_of_range& e) {
63914       {
63915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63916       };
63917     } catch (std::exception& e) {
63918       {
63919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63920       };
63921     } catch (Dali::DaliException e) {
63922       {
63923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63924       };
63925     } catch (...) {
63926       {
63927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63928       };
63929     }
63930   }
63931
63932   jresult = (void *)result;
63933   return jresult;
63934 }
63935
63936
63937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
63938   void * jresult ;
63939   float arg1 ;
63940   float arg2 ;
63941   float arg3 ;
63942   float arg4 ;
63943   Dali::Toolkit::Alignment::Padding *result = 0 ;
63944
63945   arg1 = (float)jarg1;
63946   arg2 = (float)jarg2;
63947   arg3 = (float)jarg3;
63948   arg4 = (float)jarg4;
63949   {
63950     try {
63951       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
63952     } catch (std::out_of_range& e) {
63953       {
63954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63955       };
63956     } catch (std::exception& e) {
63957       {
63958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63959       };
63960     } catch (Dali::DaliException e) {
63961       {
63962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63963       };
63964     } catch (...) {
63965       {
63966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63967       };
63968     }
63969   }
63970
63971   jresult = (void *)result;
63972   return jresult;
63973 }
63974
63975
63976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
63977   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63978   float arg2 ;
63979
63980   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63981   arg2 = (float)jarg2;
63982   if (arg1) (arg1)->left = arg2;
63983 }
63984
63985
63986 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
63987   float jresult ;
63988   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
63989   float result;
63990
63991   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
63992   result = (float) ((arg1)->left);
63993   jresult = result;
63994   return jresult;
63995 }
63996
63997
63998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
63999   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64000   float arg2 ;
64001
64002   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64003   arg2 = (float)jarg2;
64004   if (arg1) (arg1)->right = arg2;
64005 }
64006
64007
64008 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
64009   float jresult ;
64010   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64011   float result;
64012
64013   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64014   result = (float) ((arg1)->right);
64015   jresult = result;
64016   return jresult;
64017 }
64018
64019
64020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64021   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64022   float arg2 ;
64023
64024   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64025   arg2 = (float)jarg2;
64026   if (arg1) (arg1)->top = arg2;
64027 }
64028
64029
64030 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
64031   float jresult ;
64032   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64033   float result;
64034
64035   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64036   result = (float) ((arg1)->top);
64037   jresult = result;
64038   return jresult;
64039 }
64040
64041
64042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64043   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64044   float arg2 ;
64045
64046   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64047   arg2 = (float)jarg2;
64048   if (arg1) (arg1)->bottom = arg2;
64049 }
64050
64051
64052 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64053   float jresult ;
64054   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64055   float result;
64056
64057   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64058   result = (float) ((arg1)->bottom);
64059   jresult = result;
64060   return jresult;
64061 }
64062
64063
64064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64065   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64066
64067   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64068   {
64069     try {
64070       delete arg1;
64071     } catch (std::out_of_range& e) {
64072       {
64073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64074       };
64075     } catch (std::exception& e) {
64076       {
64077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64078       };
64079     } catch (Dali::DaliException e) {
64080       {
64081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64082       };
64083     } catch (...) {
64084       {
64085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64086       };
64087     }
64088   }
64089
64090 }
64091
64092
64093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64094   void * jresult ;
64095   Dali::Toolkit::Alignment *result = 0 ;
64096
64097   {
64098     try {
64099       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64100     } catch (std::out_of_range& e) {
64101       {
64102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64103       };
64104     } catch (std::exception& e) {
64105       {
64106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64107       };
64108     } catch (Dali::DaliException e) {
64109       {
64110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64111       };
64112     } catch (...) {
64113       {
64114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64115       };
64116     }
64117   }
64118
64119   jresult = (void *)result;
64120   return jresult;
64121 }
64122
64123
64124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64125   void * jresult ;
64126   Dali::Toolkit::Alignment::Type arg1 ;
64127   Dali::Toolkit::Alignment::Type arg2 ;
64128   Dali::Toolkit::Alignment result;
64129
64130   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64131   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64132   {
64133     try {
64134       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64135     } catch (std::out_of_range& e) {
64136       {
64137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64138       };
64139     } catch (std::exception& e) {
64140       {
64141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64142       };
64143     } catch (Dali::DaliException e) {
64144       {
64145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64146       };
64147     } catch (...) {
64148       {
64149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64150       };
64151     }
64152   }
64153
64154   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64155   return jresult;
64156 }
64157
64158
64159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64160   void * jresult ;
64161   Dali::Toolkit::Alignment::Type arg1 ;
64162   Dali::Toolkit::Alignment result;
64163
64164   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64165   {
64166     try {
64167       result = Dali::Toolkit::Alignment::New(arg1);
64168     } catch (std::out_of_range& e) {
64169       {
64170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64171       };
64172     } catch (std::exception& e) {
64173       {
64174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64175       };
64176     } catch (Dali::DaliException e) {
64177       {
64178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64179       };
64180     } catch (...) {
64181       {
64182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64183       };
64184     }
64185   }
64186
64187   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64188   return jresult;
64189 }
64190
64191
64192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64193   void * jresult ;
64194   Dali::Toolkit::Alignment result;
64195
64196   {
64197     try {
64198       result = Dali::Toolkit::Alignment::New();
64199     } catch (std::out_of_range& e) {
64200       {
64201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64202       };
64203     } catch (std::exception& e) {
64204       {
64205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64206       };
64207     } catch (Dali::DaliException e) {
64208       {
64209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64210       };
64211     } catch (...) {
64212       {
64213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64214       };
64215     }
64216   }
64217
64218   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64219   return jresult;
64220 }
64221
64222
64223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64224   void * jresult ;
64225   Dali::Toolkit::Alignment *arg1 = 0 ;
64226   Dali::Toolkit::Alignment *result = 0 ;
64227
64228   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64229   if (!arg1) {
64230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64231     return 0;
64232   }
64233   {
64234     try {
64235       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64236     } catch (std::out_of_range& e) {
64237       {
64238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64239       };
64240     } catch (std::exception& e) {
64241       {
64242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64243       };
64244     } catch (Dali::DaliException e) {
64245       {
64246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64247       };
64248     } catch (...) {
64249       {
64250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64251       };
64252     }
64253   }
64254
64255   jresult = (void *)result;
64256   return jresult;
64257 }
64258
64259
64260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64261   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64262
64263   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64264   {
64265     try {
64266       delete arg1;
64267     } catch (std::out_of_range& e) {
64268       {
64269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64270       };
64271     } catch (std::exception& e) {
64272       {
64273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64274       };
64275     } catch (Dali::DaliException e) {
64276       {
64277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64278       };
64279     } catch (...) {
64280       {
64281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64282       };
64283     }
64284   }
64285
64286 }
64287
64288
64289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64290   void * jresult ;
64291   Dali::BaseHandle arg1 ;
64292   Dali::BaseHandle *argp1 ;
64293   Dali::Toolkit::Alignment result;
64294
64295   argp1 = (Dali::BaseHandle *)jarg1;
64296   if (!argp1) {
64297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64298     return 0;
64299   }
64300   arg1 = *argp1;
64301   {
64302     try {
64303       result = Dali::Toolkit::Alignment::DownCast(arg1);
64304     } catch (std::out_of_range& e) {
64305       {
64306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64307       };
64308     } catch (std::exception& e) {
64309       {
64310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64311       };
64312     } catch (Dali::DaliException e) {
64313       {
64314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64315       };
64316     } catch (...) {
64317       {
64318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64319       };
64320     }
64321   }
64322
64323   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64324   return jresult;
64325 }
64326
64327
64328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64329   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64330   Dali::Toolkit::Alignment::Type arg2 ;
64331
64332   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64333   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64334   {
64335     try {
64336       (arg1)->SetAlignmentType(arg2);
64337     } catch (std::out_of_range& e) {
64338       {
64339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64340       };
64341     } catch (std::exception& e) {
64342       {
64343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64344       };
64345     } catch (Dali::DaliException e) {
64346       {
64347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64348       };
64349     } catch (...) {
64350       {
64351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64352       };
64353     }
64354   }
64355
64356 }
64357
64358
64359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64360   int jresult ;
64361   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64362   Dali::Toolkit::Alignment::Type result;
64363
64364   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64365   {
64366     try {
64367       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64368     } catch (std::out_of_range& e) {
64369       {
64370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64371       };
64372     } catch (std::exception& e) {
64373       {
64374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64375       };
64376     } catch (Dali::DaliException e) {
64377       {
64378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64379       };
64380     } catch (...) {
64381       {
64382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64383       };
64384     }
64385   }
64386
64387   jresult = (int)result;
64388   return jresult;
64389 }
64390
64391
64392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64393   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64394   Dali::Toolkit::Alignment::Scaling arg2 ;
64395
64396   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64397   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64398   {
64399     try {
64400       (arg1)->SetScaling(arg2);
64401     } catch (std::out_of_range& e) {
64402       {
64403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64404       };
64405     } catch (std::exception& e) {
64406       {
64407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64408       };
64409     } catch (Dali::DaliException e) {
64410       {
64411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64412       };
64413     } catch (...) {
64414       {
64415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64416       };
64417     }
64418   }
64419
64420 }
64421
64422
64423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64424   int jresult ;
64425   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64426   Dali::Toolkit::Alignment::Scaling result;
64427
64428   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64429   {
64430     try {
64431       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64432     } catch (std::out_of_range& e) {
64433       {
64434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64435       };
64436     } catch (std::exception& e) {
64437       {
64438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64439       };
64440     } catch (Dali::DaliException e) {
64441       {
64442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64443       };
64444     } catch (...) {
64445       {
64446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64447       };
64448     }
64449   }
64450
64451   jresult = (int)result;
64452   return jresult;
64453 }
64454
64455
64456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64457   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64458   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64459
64460   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64461   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64462   if (!arg2) {
64463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64464     return ;
64465   }
64466   {
64467     try {
64468       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64469     } catch (std::out_of_range& e) {
64470       {
64471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64472       };
64473     } catch (std::exception& e) {
64474       {
64475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64476       };
64477     } catch (Dali::DaliException e) {
64478       {
64479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64480       };
64481     } catch (...) {
64482       {
64483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64484       };
64485     }
64486   }
64487
64488 }
64489
64490
64491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
64492   void * jresult ;
64493   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64494   Dali::Toolkit::Alignment::Padding *result = 0 ;
64495
64496   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64497   {
64498     try {
64499       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64500     } catch (std::out_of_range& e) {
64501       {
64502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64503       };
64504     } catch (std::exception& e) {
64505       {
64506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64507       };
64508     } catch (Dali::DaliException e) {
64509       {
64510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64511       };
64512     } catch (...) {
64513       {
64514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64515       };
64516     }
64517   }
64518
64519   jresult = (void *)result;
64520   return jresult;
64521 }
64522
64523
64524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
64525   void * jresult ;
64526   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64527   Dali::Toolkit::Alignment *arg2 = 0 ;
64528   Dali::Toolkit::Alignment *result = 0 ;
64529
64530   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64531   arg2 = (Dali::Toolkit::Alignment *)jarg2;
64532   if (!arg2) {
64533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64534     return 0;
64535   }
64536   {
64537     try {
64538       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
64539     } catch (std::out_of_range& e) {
64540       {
64541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64542       };
64543     } catch (std::exception& e) {
64544       {
64545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64546       };
64547     } catch (Dali::DaliException e) {
64548       {
64549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64550       };
64551     } catch (...) {
64552       {
64553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64554       };
64555     }
64556   }
64557
64558   jresult = (void *)result;
64559   return jresult;
64560 }
64561
64562
64563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
64564   int jresult ;
64565   int result;
64566
64567   result = (int)Dali::Toolkit::Button::Property::DISABLED;
64568   jresult = (int)result;
64569   return jresult;
64570 }
64571
64572
64573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
64574   int jresult ;
64575   int result;
64576
64577   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
64578   jresult = (int)result;
64579   return jresult;
64580 }
64581
64582
64583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
64584   int jresult ;
64585   int result;
64586
64587   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
64588   jresult = (int)result;
64589   return jresult;
64590 }
64591
64592
64593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
64594   int jresult ;
64595   int result;
64596
64597   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
64598   jresult = (int)result;
64599   return jresult;
64600 }
64601
64602
64603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
64604   int jresult ;
64605   int result;
64606
64607   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
64608   jresult = (int)result;
64609   return jresult;
64610 }
64611
64612
64613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
64614   int jresult ;
64615   int result;
64616
64617   result = (int)Dali::Toolkit::Button::Property::SELECTED;
64618   jresult = (int)result;
64619   return jresult;
64620 }
64621
64622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
64623   int jresult ;
64624   int result;
64625
64626   result = (int)Dali::Toolkit::Button::Property::LABEL;
64627   jresult = (int)result;
64628   return jresult;
64629 }
64630
64631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
64632   void * jresult ;
64633   Dali::Toolkit::Button::Property *result = 0 ;
64634
64635   {
64636     try {
64637       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
64638     } catch (std::out_of_range& e) {
64639       {
64640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64641       };
64642     } catch (std::exception& e) {
64643       {
64644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64645       };
64646     } catch (Dali::DaliException e) {
64647       {
64648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64649       };
64650     } catch (...) {
64651       {
64652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64653       };
64654     }
64655   }
64656
64657   jresult = (void *)result;
64658   return jresult;
64659 }
64660
64661
64662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
64663   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
64664
64665   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
64666   {
64667     try {
64668       delete arg1;
64669     } catch (std::out_of_range& e) {
64670       {
64671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64672       };
64673     } catch (std::exception& e) {
64674       {
64675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64676       };
64677     } catch (Dali::DaliException e) {
64678       {
64679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64680       };
64681     } catch (...) {
64682       {
64683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64684       };
64685     }
64686   }
64687
64688 }
64689
64690
64691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
64692   void * jresult ;
64693   Dali::Toolkit::Button *result = 0 ;
64694
64695   {
64696     try {
64697       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
64698     } catch (std::out_of_range& e) {
64699       {
64700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64701       };
64702     } catch (std::exception& e) {
64703       {
64704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64705       };
64706     } catch (Dali::DaliException e) {
64707       {
64708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64709       };
64710     } catch (...) {
64711       {
64712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64713       };
64714     }
64715   }
64716
64717   jresult = (void *)result;
64718   return jresult;
64719 }
64720
64721
64722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
64723   void * jresult ;
64724   Dali::Toolkit::Button *arg1 = 0 ;
64725   Dali::Toolkit::Button *result = 0 ;
64726
64727   arg1 = (Dali::Toolkit::Button *)jarg1;
64728   if (!arg1) {
64729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64730     return 0;
64731   }
64732   {
64733     try {
64734       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
64735     } catch (std::out_of_range& e) {
64736       {
64737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64738       };
64739     } catch (std::exception& e) {
64740       {
64741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64742       };
64743     } catch (Dali::DaliException e) {
64744       {
64745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64746       };
64747     } catch (...) {
64748       {
64749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64750       };
64751     }
64752   }
64753
64754   jresult = (void *)result;
64755   return jresult;
64756 }
64757
64758
64759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
64760   void * jresult ;
64761   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64762   Dali::Toolkit::Button *arg2 = 0 ;
64763   Dali::Toolkit::Button *result = 0 ;
64764
64765   arg1 = (Dali::Toolkit::Button *)jarg1;
64766   arg2 = (Dali::Toolkit::Button *)jarg2;
64767   if (!arg2) {
64768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64769     return 0;
64770   }
64771   {
64772     try {
64773       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
64774     } catch (std::out_of_range& e) {
64775       {
64776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64777       };
64778     } catch (std::exception& e) {
64779       {
64780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64781       };
64782     } catch (Dali::DaliException e) {
64783       {
64784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64785       };
64786     } catch (...) {
64787       {
64788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64789       };
64790     }
64791   }
64792
64793   jresult = (void *)result;
64794   return jresult;
64795 }
64796
64797
64798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
64799   void * jresult ;
64800   Dali::BaseHandle arg1 ;
64801   Dali::BaseHandle *argp1 ;
64802   Dali::Toolkit::Button result;
64803
64804   argp1 = (Dali::BaseHandle *)jarg1;
64805   if (!argp1) {
64806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64807     return 0;
64808   }
64809   arg1 = *argp1;
64810   {
64811     try {
64812       result = Dali::Toolkit::Button::DownCast(arg1);
64813     } catch (std::out_of_range& e) {
64814       {
64815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64816       };
64817     } catch (std::exception& e) {
64818       {
64819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64820       };
64821     } catch (Dali::DaliException e) {
64822       {
64823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64824       };
64825     } catch (...) {
64826       {
64827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64828       };
64829     }
64830   }
64831
64832   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
64833   return jresult;
64834 }
64835
64836
64837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
64838   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64839
64840   arg1 = (Dali::Toolkit::Button *)jarg1;
64841   {
64842     try {
64843       delete arg1;
64844     } catch (std::out_of_range& e) {
64845       {
64846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64847       };
64848     } catch (std::exception& e) {
64849       {
64850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64851       };
64852     } catch (Dali::DaliException e) {
64853       {
64854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64855       };
64856     } catch (...) {
64857       {
64858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64859       };
64860     }
64861   }
64862
64863 }
64864
64865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
64866   void * jresult ;
64867   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64868   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64869
64870   arg1 = (Dali::Toolkit::Button *)jarg1;
64871   {
64872     try {
64873       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
64874     } catch (std::out_of_range& e) {
64875       {
64876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64877       };
64878     } catch (std::exception& e) {
64879       {
64880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64881       };
64882     } catch (Dali::DaliException e) {
64883       {
64884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64885       };
64886     } catch (...) {
64887       {
64888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64889       };
64890     }
64891   }
64892
64893   jresult = (void *)result;
64894   return jresult;
64895 }
64896
64897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
64898   void * jresult ;
64899   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64900   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64901
64902   arg1 = (Dali::Toolkit::Button *)jarg1;
64903   {
64904     try {
64905       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
64906     } catch (std::out_of_range& e) {
64907       {
64908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64909       };
64910     } catch (std::exception& e) {
64911       {
64912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64913       };
64914     } catch (Dali::DaliException e) {
64915       {
64916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64917       };
64918     } catch (...) {
64919       {
64920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64921       };
64922     }
64923   }
64924
64925   jresult = (void *)result;
64926   return jresult;
64927 }
64928
64929
64930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
64931   void * jresult ;
64932   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64933   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64934
64935   arg1 = (Dali::Toolkit::Button *)jarg1;
64936   {
64937     try {
64938       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
64939     } catch (std::out_of_range& e) {
64940       {
64941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64942       };
64943     } catch (std::exception& e) {
64944       {
64945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64946       };
64947     } catch (Dali::DaliException e) {
64948       {
64949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64950       };
64951     } catch (...) {
64952       {
64953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64954       };
64955     }
64956   }
64957
64958   jresult = (void *)result;
64959   return jresult;
64960 }
64961
64962
64963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
64964   void * jresult ;
64965   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64966   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
64967
64968   arg1 = (Dali::Toolkit::Button *)jarg1;
64969   {
64970     try {
64971       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
64972     } catch (std::out_of_range& e) {
64973       {
64974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64975       };
64976     } catch (std::exception& e) {
64977       {
64978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64979       };
64980     } catch (Dali::DaliException e) {
64981       {
64982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64983       };
64984     } catch (...) {
64985       {
64986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64987       };
64988     }
64989   }
64990
64991   jresult = (void *)result;
64992   return jresult;
64993 }
64994
64995
64996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
64997   void * jresult ;
64998   Dali::Toolkit::CheckBoxButton *result = 0 ;
64999
65000   {
65001     try {
65002       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65003     } catch (std::out_of_range& e) {
65004       {
65005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65006       };
65007     } catch (std::exception& e) {
65008       {
65009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65010       };
65011     } catch (Dali::DaliException e) {
65012       {
65013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65014       };
65015     } catch (...) {
65016       {
65017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65018       };
65019     }
65020   }
65021
65022   jresult = (void *)result;
65023   return jresult;
65024 }
65025
65026
65027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65028   void * jresult ;
65029   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65030   Dali::Toolkit::CheckBoxButton *result = 0 ;
65031
65032   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65033   if (!arg1) {
65034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65035     return 0;
65036   }
65037   {
65038     try {
65039       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65040     } catch (std::out_of_range& e) {
65041       {
65042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65043       };
65044     } catch (std::exception& e) {
65045       {
65046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65047       };
65048     } catch (Dali::DaliException e) {
65049       {
65050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65051       };
65052     } catch (...) {
65053       {
65054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65055       };
65056     }
65057   }
65058
65059   jresult = (void *)result;
65060   return jresult;
65061 }
65062
65063
65064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65065   void * jresult ;
65066   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65067   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65068   Dali::Toolkit::CheckBoxButton *result = 0 ;
65069
65070   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65071   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65072   if (!arg2) {
65073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65074     return 0;
65075   }
65076   {
65077     try {
65078       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65079     } catch (std::out_of_range& e) {
65080       {
65081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65082       };
65083     } catch (std::exception& e) {
65084       {
65085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65086       };
65087     } catch (Dali::DaliException e) {
65088       {
65089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65090       };
65091     } catch (...) {
65092       {
65093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65094       };
65095     }
65096   }
65097
65098   jresult = (void *)result;
65099   return jresult;
65100 }
65101
65102
65103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65104   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65105
65106   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65107   {
65108     try {
65109       delete arg1;
65110     } catch (std::out_of_range& e) {
65111       {
65112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65113       };
65114     } catch (std::exception& e) {
65115       {
65116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65117       };
65118     } catch (Dali::DaliException e) {
65119       {
65120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65121       };
65122     } catch (...) {
65123       {
65124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65125       };
65126     }
65127   }
65128
65129 }
65130
65131
65132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65133   void * jresult ;
65134   Dali::Toolkit::CheckBoxButton result;
65135
65136   {
65137     try {
65138       result = Dali::Toolkit::CheckBoxButton::New();
65139     } catch (std::out_of_range& e) {
65140       {
65141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65142       };
65143     } catch (std::exception& e) {
65144       {
65145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65146       };
65147     } catch (Dali::DaliException e) {
65148       {
65149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65150       };
65151     } catch (...) {
65152       {
65153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65154       };
65155     }
65156   }
65157
65158   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65159   return jresult;
65160 }
65161
65162
65163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65164   void * jresult ;
65165   Dali::BaseHandle arg1 ;
65166   Dali::BaseHandle *argp1 ;
65167   Dali::Toolkit::CheckBoxButton result;
65168
65169   argp1 = (Dali::BaseHandle *)jarg1;
65170   if (!argp1) {
65171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65172     return 0;
65173   }
65174   arg1 = *argp1;
65175   {
65176     try {
65177       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65178     } catch (std::out_of_range& e) {
65179       {
65180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65181       };
65182     } catch (std::exception& e) {
65183       {
65184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65185       };
65186     } catch (Dali::DaliException e) {
65187       {
65188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65189       };
65190     } catch (...) {
65191       {
65192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65193       };
65194     }
65195   }
65196
65197   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65198   return jresult;
65199 }
65200
65201
65202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
65203   int jresult ;
65204   int result;
65205
65206   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65207   jresult = (int)result;
65208   return jresult;
65209 }
65210
65211
65212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
65213   int jresult ;
65214   int result;
65215
65216   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65217   jresult = (int)result;
65218   return jresult;
65219 }
65220
65221
65222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
65223   void * jresult ;
65224   Dali::Toolkit::PushButton::Property *result = 0 ;
65225
65226   {
65227     try {
65228       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65229     } catch (std::out_of_range& e) {
65230       {
65231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65232       };
65233     } catch (std::exception& e) {
65234       {
65235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65236       };
65237     } catch (Dali::DaliException e) {
65238       {
65239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65240       };
65241     } catch (...) {
65242       {
65243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65244       };
65245     }
65246   }
65247
65248   jresult = (void *)result;
65249   return jresult;
65250 }
65251
65252
65253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
65254   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65255
65256   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65257   {
65258     try {
65259       delete arg1;
65260     } catch (std::out_of_range& e) {
65261       {
65262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65263       };
65264     } catch (std::exception& e) {
65265       {
65266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65267       };
65268     } catch (Dali::DaliException e) {
65269       {
65270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65271       };
65272     } catch (...) {
65273       {
65274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65275       };
65276     }
65277   }
65278
65279 }
65280
65281
65282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65283   void * jresult ;
65284   Dali::Toolkit::PushButton *result = 0 ;
65285
65286   {
65287     try {
65288       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65289     } catch (std::out_of_range& e) {
65290       {
65291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65292       };
65293     } catch (std::exception& e) {
65294       {
65295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65296       };
65297     } catch (Dali::DaliException e) {
65298       {
65299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65300       };
65301     } catch (...) {
65302       {
65303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65304       };
65305     }
65306   }
65307
65308   jresult = (void *)result;
65309   return jresult;
65310 }
65311
65312
65313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
65314   void * jresult ;
65315   Dali::Toolkit::PushButton *arg1 = 0 ;
65316   Dali::Toolkit::PushButton *result = 0 ;
65317
65318   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65319   if (!arg1) {
65320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65321     return 0;
65322   }
65323   {
65324     try {
65325       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65326     } catch (std::out_of_range& e) {
65327       {
65328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65329       };
65330     } catch (std::exception& e) {
65331       {
65332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65333       };
65334     } catch (Dali::DaliException e) {
65335       {
65336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65337       };
65338     } catch (...) {
65339       {
65340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65341       };
65342     }
65343   }
65344
65345   jresult = (void *)result;
65346   return jresult;
65347 }
65348
65349
65350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
65351   void * jresult ;
65352   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65353   Dali::Toolkit::PushButton *arg2 = 0 ;
65354   Dali::Toolkit::PushButton *result = 0 ;
65355
65356   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65357   arg2 = (Dali::Toolkit::PushButton *)jarg2;
65358   if (!arg2) {
65359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65360     return 0;
65361   }
65362   {
65363     try {
65364       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
65365     } catch (std::out_of_range& e) {
65366       {
65367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65368       };
65369     } catch (std::exception& e) {
65370       {
65371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65372       };
65373     } catch (Dali::DaliException e) {
65374       {
65375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65376       };
65377     } catch (...) {
65378       {
65379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65380       };
65381     }
65382   }
65383
65384   jresult = (void *)result;
65385   return jresult;
65386 }
65387
65388
65389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
65390   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65391
65392   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65393   {
65394     try {
65395       delete arg1;
65396     } catch (std::out_of_range& e) {
65397       {
65398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65399       };
65400     } catch (std::exception& e) {
65401       {
65402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65403       };
65404     } catch (Dali::DaliException e) {
65405       {
65406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65407       };
65408     } catch (...) {
65409       {
65410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65411       };
65412     }
65413   }
65414
65415 }
65416
65417
65418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
65419   void * jresult ;
65420   Dali::Toolkit::PushButton result;
65421
65422   {
65423     try {
65424       result = Dali::Toolkit::PushButton::New();
65425     } catch (std::out_of_range& e) {
65426       {
65427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65428       };
65429     } catch (std::exception& e) {
65430       {
65431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65432       };
65433     } catch (Dali::DaliException e) {
65434       {
65435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65436       };
65437     } catch (...) {
65438       {
65439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65440       };
65441     }
65442   }
65443
65444   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65445   return jresult;
65446 }
65447
65448
65449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65450   void * jresult ;
65451   Dali::BaseHandle arg1 ;
65452   Dali::BaseHandle *argp1 ;
65453   Dali::Toolkit::PushButton result;
65454
65455   argp1 = (Dali::BaseHandle *)jarg1;
65456   if (!argp1) {
65457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65458     return 0;
65459   }
65460   arg1 = *argp1;
65461   {
65462     try {
65463       result = Dali::Toolkit::PushButton::DownCast(arg1);
65464     } catch (std::out_of_range& e) {
65465       {
65466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65467       };
65468     } catch (std::exception& e) {
65469       {
65470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65471       };
65472     } catch (Dali::DaliException e) {
65473       {
65474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65475       };
65476     } catch (...) {
65477       {
65478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65479       };
65480     }
65481   }
65482
65483   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65484   return jresult;
65485 }
65486
65487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65488   void * jresult ;
65489   Dali::Toolkit::RadioButton *result = 0 ;
65490
65491   {
65492     try {
65493       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65494     } catch (std::out_of_range& e) {
65495       {
65496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65497       };
65498     } catch (std::exception& e) {
65499       {
65500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65501       };
65502     } catch (Dali::DaliException e) {
65503       {
65504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65505       };
65506     } catch (...) {
65507       {
65508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65509       };
65510     }
65511   }
65512
65513   jresult = (void *)result;
65514   return jresult;
65515 }
65516
65517
65518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65519   void * jresult ;
65520   Dali::Toolkit::RadioButton *arg1 = 0 ;
65521   Dali::Toolkit::RadioButton *result = 0 ;
65522
65523   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65524   if (!arg1) {
65525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65526     return 0;
65527   }
65528   {
65529     try {
65530       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65531     } catch (std::out_of_range& e) {
65532       {
65533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65534       };
65535     } catch (std::exception& e) {
65536       {
65537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65538       };
65539     } catch (Dali::DaliException e) {
65540       {
65541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65542       };
65543     } catch (...) {
65544       {
65545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65546       };
65547     }
65548   }
65549
65550   jresult = (void *)result;
65551   return jresult;
65552 }
65553
65554
65555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65556   void * jresult ;
65557   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65558   Dali::Toolkit::RadioButton *arg2 = 0 ;
65559   Dali::Toolkit::RadioButton *result = 0 ;
65560
65561   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65562   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65563   if (!arg2) {
65564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65565     return 0;
65566   }
65567   {
65568     try {
65569       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65570     } catch (std::out_of_range& e) {
65571       {
65572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65573       };
65574     } catch (std::exception& e) {
65575       {
65576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65577       };
65578     } catch (Dali::DaliException e) {
65579       {
65580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65581       };
65582     } catch (...) {
65583       {
65584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65585       };
65586     }
65587   }
65588
65589   jresult = (void *)result;
65590   return jresult;
65591 }
65592
65593
65594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65595   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65596
65597   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65598   {
65599     try {
65600       delete arg1;
65601     } catch (std::out_of_range& e) {
65602       {
65603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65604       };
65605     } catch (std::exception& e) {
65606       {
65607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65608       };
65609     } catch (Dali::DaliException e) {
65610       {
65611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65612       };
65613     } catch (...) {
65614       {
65615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65616       };
65617     }
65618   }
65619
65620 }
65621
65622
65623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65624   void * jresult ;
65625   Dali::Toolkit::RadioButton result;
65626
65627   {
65628     try {
65629       result = Dali::Toolkit::RadioButton::New();
65630     } catch (std::out_of_range& e) {
65631       {
65632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65633       };
65634     } catch (std::exception& e) {
65635       {
65636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65637       };
65638     } catch (Dali::DaliException e) {
65639       {
65640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65641       };
65642     } catch (...) {
65643       {
65644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65645       };
65646     }
65647   }
65648
65649   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65650   return jresult;
65651 }
65652
65653
65654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
65655   void * jresult ;
65656   std::string *arg1 = 0 ;
65657   Dali::Toolkit::RadioButton result;
65658
65659   if (!jarg1) {
65660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65661     return 0;
65662   }
65663   std::string arg1_str(jarg1);
65664   arg1 = &arg1_str;
65665   {
65666     try {
65667       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
65668     } catch (std::out_of_range& e) {
65669       {
65670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65671       };
65672     } catch (std::exception& e) {
65673       {
65674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65675       };
65676     } catch (Dali::DaliException e) {
65677       {
65678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65679       };
65680     } catch (...) {
65681       {
65682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65683       };
65684     }
65685   }
65686
65687   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65688
65689   //argout typemap for const std::string&
65690
65691   return jresult;
65692 }
65693
65694
65695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
65696   void * jresult ;
65697   Dali::BaseHandle arg1 ;
65698   Dali::BaseHandle *argp1 ;
65699   Dali::Toolkit::RadioButton result;
65700
65701   argp1 = (Dali::BaseHandle *)jarg1;
65702   if (!argp1) {
65703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65704     return 0;
65705   }
65706   arg1 = *argp1;
65707   {
65708     try {
65709       result = Dali::Toolkit::RadioButton::DownCast(arg1);
65710     } catch (std::out_of_range& e) {
65711       {
65712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65713       };
65714     } catch (std::exception& e) {
65715       {
65716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65717       };
65718     } catch (Dali::DaliException e) {
65719       {
65720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65721       };
65722     } catch (...) {
65723       {
65724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65725       };
65726     }
65727   }
65728
65729   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65730   return jresult;
65731 }
65732
65733
65734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
65735   int jresult ;
65736   int result;
65737
65738   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
65739   jresult = (int)result;
65740   return jresult;
65741 }
65742
65743
65744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
65745   int jresult ;
65746   int result;
65747
65748   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
65749   jresult = (int)result;
65750   return jresult;
65751 }
65752
65753
65754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
65755   int jresult ;
65756   int result;
65757
65758   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
65759   jresult = (int)result;
65760   return jresult;
65761 }
65762
65763
65764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
65765   int jresult ;
65766   int result;
65767
65768   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
65769   jresult = (int)result;
65770   return jresult;
65771 }
65772
65773
65774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
65775   int jresult ;
65776   int result;
65777
65778   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
65779   jresult = (int)result;
65780   return jresult;
65781 }
65782
65783
65784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
65785   int jresult ;
65786   int result;
65787
65788   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
65789   jresult = (int)result;
65790   return jresult;
65791 }
65792
65793
65794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
65795   void * jresult ;
65796   Dali::Toolkit::FlexContainer::Property *result = 0 ;
65797
65798   {
65799     try {
65800       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
65801     } catch (std::out_of_range& e) {
65802       {
65803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65804       };
65805     } catch (std::exception& e) {
65806       {
65807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65808       };
65809     } catch (Dali::DaliException e) {
65810       {
65811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65812       };
65813     } catch (...) {
65814       {
65815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65816       };
65817     }
65818   }
65819
65820   jresult = (void *)result;
65821   return jresult;
65822 }
65823
65824
65825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
65826   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
65827
65828   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
65829   {
65830     try {
65831       delete arg1;
65832     } catch (std::out_of_range& e) {
65833       {
65834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65835       };
65836     } catch (std::exception& e) {
65837       {
65838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65839       };
65840     } catch (Dali::DaliException e) {
65841       {
65842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65843       };
65844     } catch (...) {
65845       {
65846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65847       };
65848     }
65849   }
65850
65851 }
65852
65853
65854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
65855   int jresult ;
65856   int result;
65857
65858   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
65859   jresult = (int)result;
65860   return jresult;
65861 }
65862
65863
65864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
65865   int jresult ;
65866   int result;
65867
65868   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
65869   jresult = (int)result;
65870   return jresult;
65871 }
65872
65873
65874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
65875   int jresult ;
65876   int result;
65877
65878   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
65879   jresult = (int)result;
65880   return jresult;
65881 }
65882
65883
65884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
65885   void * jresult ;
65886   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
65887
65888   {
65889     try {
65890       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
65891     } catch (std::out_of_range& e) {
65892       {
65893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65894       };
65895     } catch (std::exception& e) {
65896       {
65897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65898       };
65899     } catch (Dali::DaliException e) {
65900       {
65901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65902       };
65903     } catch (...) {
65904       {
65905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65906       };
65907     }
65908   }
65909
65910   jresult = (void *)result;
65911   return jresult;
65912 }
65913
65914
65915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
65916   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
65917
65918   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
65919   {
65920     try {
65921       delete arg1;
65922     } catch (std::out_of_range& e) {
65923       {
65924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65925       };
65926     } catch (std::exception& e) {
65927       {
65928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65929       };
65930     } catch (Dali::DaliException e) {
65931       {
65932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65933       };
65934     } catch (...) {
65935       {
65936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65937       };
65938     }
65939   }
65940
65941 }
65942
65943
65944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
65945   void * jresult ;
65946   Dali::Toolkit::FlexContainer *result = 0 ;
65947
65948   {
65949     try {
65950       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
65951     } catch (std::out_of_range& e) {
65952       {
65953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65954       };
65955     } catch (std::exception& e) {
65956       {
65957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65958       };
65959     } catch (Dali::DaliException e) {
65960       {
65961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65962       };
65963     } catch (...) {
65964       {
65965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65966       };
65967     }
65968   }
65969
65970   jresult = (void *)result;
65971   return jresult;
65972 }
65973
65974
65975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
65976   void * jresult ;
65977   Dali::Toolkit::FlexContainer *arg1 = 0 ;
65978   Dali::Toolkit::FlexContainer *result = 0 ;
65979
65980   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
65981   if (!arg1) {
65982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
65983     return 0;
65984   }
65985   {
65986     try {
65987       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
65988     } catch (std::out_of_range& e) {
65989       {
65990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65991       };
65992     } catch (std::exception& e) {
65993       {
65994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65995       };
65996     } catch (Dali::DaliException e) {
65997       {
65998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65999       };
66000     } catch (...) {
66001       {
66002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66003       };
66004     }
66005   }
66006
66007   jresult = (void *)result;
66008   return jresult;
66009 }
66010
66011
66012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66013   void * jresult ;
66014   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66015   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66016   Dali::Toolkit::FlexContainer *result = 0 ;
66017
66018   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66019   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66020   if (!arg2) {
66021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66022     return 0;
66023   }
66024   {
66025     try {
66026       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66027     } catch (std::out_of_range& e) {
66028       {
66029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66030       };
66031     } catch (std::exception& e) {
66032       {
66033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66034       };
66035     } catch (Dali::DaliException e) {
66036       {
66037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66038       };
66039     } catch (...) {
66040       {
66041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66042       };
66043     }
66044   }
66045
66046   jresult = (void *)result;
66047   return jresult;
66048 }
66049
66050
66051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
66052   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66053
66054   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66055   {
66056     try {
66057       delete arg1;
66058     } catch (std::out_of_range& e) {
66059       {
66060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66061       };
66062     } catch (std::exception& e) {
66063       {
66064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66065       };
66066     } catch (Dali::DaliException e) {
66067       {
66068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66069       };
66070     } catch (...) {
66071       {
66072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66073       };
66074     }
66075   }
66076
66077 }
66078
66079
66080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
66081   void * jresult ;
66082   Dali::Toolkit::FlexContainer result;
66083
66084   {
66085     try {
66086       result = Dali::Toolkit::FlexContainer::New();
66087     } catch (std::out_of_range& e) {
66088       {
66089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66090       };
66091     } catch (std::exception& e) {
66092       {
66093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66094       };
66095     } catch (Dali::DaliException e) {
66096       {
66097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66098       };
66099     } catch (...) {
66100       {
66101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66102       };
66103     }
66104   }
66105
66106   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66107   return jresult;
66108 }
66109
66110
66111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66112   void * jresult ;
66113   Dali::BaseHandle arg1 ;
66114   Dali::BaseHandle *argp1 ;
66115   Dali::Toolkit::FlexContainer result;
66116
66117   argp1 = (Dali::BaseHandle *)jarg1;
66118   if (!argp1) {
66119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66120     return 0;
66121   }
66122   arg1 = *argp1;
66123   {
66124     try {
66125       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66126     } catch (std::out_of_range& e) {
66127       {
66128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66129       };
66130     } catch (std::exception& e) {
66131       {
66132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66133       };
66134     } catch (Dali::DaliException e) {
66135       {
66136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66137       };
66138     } catch (...) {
66139       {
66140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66141       };
66142     }
66143   }
66144
66145   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66146   return jresult;
66147 }
66148
66149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
66150   int jresult ;
66151   int result;
66152
66153   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66154   jresult = (int)result;
66155   return jresult;
66156 }
66157
66158
66159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66160   int jresult ;
66161   int result;
66162
66163   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66164   jresult = (int)result;
66165   return jresult;
66166 }
66167
66168
66169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
66170   int jresult ;
66171   int result;
66172
66173   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66174   jresult = (int)result;
66175   return jresult;
66176 }
66177
66178
66179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
66180   void * jresult ;
66181   Dali::Toolkit::ImageView::Property *result = 0 ;
66182
66183   {
66184     try {
66185       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
66186     } catch (std::out_of_range& e) {
66187       {
66188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66189       };
66190     } catch (std::exception& e) {
66191       {
66192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66193       };
66194     } catch (Dali::DaliException e) {
66195       {
66196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66197       };
66198     } catch (...) {
66199       {
66200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66201       };
66202     }
66203   }
66204
66205   jresult = (void *)result;
66206   return jresult;
66207 }
66208
66209
66210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
66211   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66212
66213   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66214   {
66215     try {
66216       delete arg1;
66217     } catch (std::out_of_range& e) {
66218       {
66219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66220       };
66221     } catch (std::exception& e) {
66222       {
66223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66224       };
66225     } catch (Dali::DaliException e) {
66226       {
66227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66228       };
66229     } catch (...) {
66230       {
66231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66232       };
66233     }
66234   }
66235
66236 }
66237
66238
66239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66240   void * jresult ;
66241   Dali::Toolkit::ImageView *result = 0 ;
66242
66243   {
66244     try {
66245       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66246     } catch (std::out_of_range& e) {
66247       {
66248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66249       };
66250     } catch (std::exception& e) {
66251       {
66252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66253       };
66254     } catch (Dali::DaliException e) {
66255       {
66256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66257       };
66258     } catch (...) {
66259       {
66260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66261       };
66262     }
66263   }
66264
66265   jresult = (void *)result;
66266   return jresult;
66267 }
66268
66269
66270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66271   void * jresult ;
66272   Dali::Toolkit::ImageView result;
66273
66274   {
66275     try {
66276       result = Dali::Toolkit::ImageView::New();
66277     } catch (std::out_of_range& e) {
66278       {
66279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66280       };
66281     } catch (std::exception& e) {
66282       {
66283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66284       };
66285     } catch (Dali::DaliException e) {
66286       {
66287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66288       };
66289     } catch (...) {
66290       {
66291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66292       };
66293     }
66294   }
66295
66296   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66297   return jresult;
66298 }
66299
66300
66301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66302   void * jresult ;
66303   std::string *arg1 = 0 ;
66304   Dali::Toolkit::ImageView result;
66305
66306   if (!jarg1) {
66307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66308     return 0;
66309   }
66310   std::string arg1_str(jarg1);
66311   arg1 = &arg1_str;
66312   {
66313     try {
66314       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66315     } catch (std::out_of_range& e) {
66316       {
66317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66318       };
66319     } catch (std::exception& e) {
66320       {
66321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66322       };
66323     } catch (Dali::DaliException e) {
66324       {
66325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66326       };
66327     } catch (...) {
66328       {
66329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66330       };
66331     }
66332   }
66333
66334   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66335
66336   //argout typemap for const std::string&
66337
66338   return jresult;
66339 }
66340
66341
66342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66343   void * jresult ;
66344   std::string *arg1 = 0 ;
66345   Dali::ImageDimensions arg2 ;
66346   Dali::ImageDimensions *argp2 ;
66347   Dali::Toolkit::ImageView result;
66348
66349   if (!jarg1) {
66350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66351     return 0;
66352   }
66353   std::string arg1_str(jarg1);
66354   arg1 = &arg1_str;
66355   argp2 = (Dali::ImageDimensions *)jarg2;
66356   if (!argp2) {
66357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66358     return 0;
66359   }
66360   arg2 = *argp2;
66361   {
66362     try {
66363       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66364     } catch (std::out_of_range& e) {
66365       {
66366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66367       };
66368     } catch (std::exception& e) {
66369       {
66370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66371       };
66372     } catch (Dali::DaliException e) {
66373       {
66374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66375       };
66376     } catch (...) {
66377       {
66378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66379       };
66380     }
66381   }
66382
66383   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66384
66385   //argout typemap for const std::string&
66386
66387   return jresult;
66388 }
66389
66390
66391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66392   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66393
66394   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66395   {
66396     try {
66397       delete arg1;
66398     } catch (std::out_of_range& e) {
66399       {
66400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66401       };
66402     } catch (std::exception& e) {
66403       {
66404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66405       };
66406     } catch (Dali::DaliException e) {
66407       {
66408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66409       };
66410     } catch (...) {
66411       {
66412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66413       };
66414     }
66415   }
66416
66417 }
66418
66419
66420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66421   void * jresult ;
66422   Dali::Toolkit::ImageView *arg1 = 0 ;
66423   Dali::Toolkit::ImageView *result = 0 ;
66424
66425   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66426   if (!arg1) {
66427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66428     return 0;
66429   }
66430   {
66431     try {
66432       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66433     } catch (std::out_of_range& e) {
66434       {
66435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66436       };
66437     } catch (std::exception& e) {
66438       {
66439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66440       };
66441     } catch (Dali::DaliException e) {
66442       {
66443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66444       };
66445     } catch (...) {
66446       {
66447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66448       };
66449     }
66450   }
66451
66452   jresult = (void *)result;
66453   return jresult;
66454 }
66455
66456
66457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66458   void * jresult ;
66459   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66460   Dali::Toolkit::ImageView *arg2 = 0 ;
66461   Dali::Toolkit::ImageView *result = 0 ;
66462
66463   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66464   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66465   if (!arg2) {
66466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66467     return 0;
66468   }
66469   {
66470     try {
66471       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66472     } catch (std::out_of_range& e) {
66473       {
66474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66475       };
66476     } catch (std::exception& e) {
66477       {
66478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66479       };
66480     } catch (Dali::DaliException e) {
66481       {
66482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66483       };
66484     } catch (...) {
66485       {
66486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66487       };
66488     }
66489   }
66490
66491   jresult = (void *)result;
66492   return jresult;
66493 }
66494
66495
66496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
66497   void * jresult ;
66498   Dali::BaseHandle arg1 ;
66499   Dali::BaseHandle *argp1 ;
66500   Dali::Toolkit::ImageView result;
66501
66502   argp1 = (Dali::BaseHandle *)jarg1;
66503   if (!argp1) {
66504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66505     return 0;
66506   }
66507   arg1 = *argp1;
66508   {
66509     try {
66510       result = Dali::Toolkit::ImageView::DownCast(arg1);
66511     } catch (std::out_of_range& e) {
66512       {
66513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66514       };
66515     } catch (std::exception& e) {
66516       {
66517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66518       };
66519     } catch (Dali::DaliException e) {
66520       {
66521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66522       };
66523     } catch (...) {
66524       {
66525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66526       };
66527     }
66528   }
66529
66530   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66531   return jresult;
66532 }
66533
66534
66535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
66536   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66537   std::string *arg2 = 0 ;
66538
66539   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66540   if (!jarg2) {
66541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66542     return ;
66543   }
66544   std::string arg2_str(jarg2);
66545   arg2 = &arg2_str;
66546   {
66547     try {
66548       (arg1)->SetImage((std::string const &)*arg2);
66549     } catch (std::out_of_range& e) {
66550       {
66551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66552       };
66553     } catch (std::exception& e) {
66554       {
66555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66556       };
66557     } catch (Dali::DaliException e) {
66558       {
66559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66560       };
66561     } catch (...) {
66562       {
66563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66564       };
66565     }
66566   }
66567
66568
66569   //argout typemap for const std::string&
66570
66571 }
66572
66573
66574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66575   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66576   std::string *arg2 = 0 ;
66577   Dali::ImageDimensions arg3 ;
66578   Dali::ImageDimensions *argp3 ;
66579
66580   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66581   if (!jarg2) {
66582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66583     return ;
66584   }
66585   std::string arg2_str(jarg2);
66586   arg2 = &arg2_str;
66587   argp3 = (Dali::ImageDimensions *)jarg3;
66588   if (!argp3) {
66589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66590     return ;
66591   }
66592   arg3 = *argp3;
66593   {
66594     try {
66595       (arg1)->SetImage((std::string const &)*arg2,arg3);
66596     } catch (std::out_of_range& e) {
66597       {
66598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66599       };
66600     } catch (std::exception& e) {
66601       {
66602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66603       };
66604     } catch (Dali::DaliException e) {
66605       {
66606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66607       };
66608     } catch (...) {
66609       {
66610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66611       };
66612     }
66613   }
66614
66615
66616   //argout typemap for const std::string&
66617
66618 }
66619
66620
66621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66622   int jresult ;
66623   int result;
66624
66625   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66626   jresult = (int)result;
66627   return jresult;
66628 }
66629
66630
66631 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66632   int jresult ;
66633   int result;
66634
66635   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66636   jresult = (int)result;
66637   return jresult;
66638 }
66639
66640
66641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66642   int jresult ;
66643   int result;
66644
66645   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66646   jresult = (int)result;
66647   return jresult;
66648 }
66649
66650
66651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66652   int jresult ;
66653   int result;
66654
66655   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
66656   jresult = (int)result;
66657   return jresult;
66658 }
66659
66660
66661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
66662   int jresult ;
66663   int result;
66664
66665   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
66666   jresult = (int)result;
66667   return jresult;
66668 }
66669
66670
66671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
66672   int jresult ;
66673   int result;
66674
66675   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
66676   jresult = (int)result;
66677   return jresult;
66678 }
66679
66680
66681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
66682   int jresult ;
66683   int result;
66684
66685   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
66686   jresult = (int)result;
66687   return jresult;
66688 }
66689
66690
66691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
66692   int jresult ;
66693   int result;
66694
66695   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
66696   jresult = (int)result;
66697   return jresult;
66698 }
66699
66700
66701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
66702   void * jresult ;
66703   Dali::Toolkit::Model3dView::Property *result = 0 ;
66704
66705   {
66706     try {
66707       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
66708     } catch (std::out_of_range& e) {
66709       {
66710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66711       };
66712     } catch (std::exception& e) {
66713       {
66714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66715       };
66716     } catch (Dali::DaliException e) {
66717       {
66718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66719       };
66720     } catch (...) {
66721       {
66722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66723       };
66724     }
66725   }
66726
66727   jresult = (void *)result;
66728   return jresult;
66729 }
66730
66731
66732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
66733   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
66734
66735   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
66736   {
66737     try {
66738       delete arg1;
66739     } catch (std::out_of_range& e) {
66740       {
66741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66742       };
66743     } catch (std::exception& e) {
66744       {
66745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66746       };
66747     } catch (Dali::DaliException e) {
66748       {
66749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66750       };
66751     } catch (...) {
66752       {
66753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66754       };
66755     }
66756   }
66757
66758 }
66759
66760
66761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
66762   void * jresult ;
66763   Dali::Toolkit::Model3dView result;
66764
66765   {
66766     try {
66767       result = Dali::Toolkit::Model3dView::New();
66768     } catch (std::out_of_range& e) {
66769       {
66770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66771       };
66772     } catch (std::exception& e) {
66773       {
66774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66775       };
66776     } catch (Dali::DaliException e) {
66777       {
66778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66779       };
66780     } catch (...) {
66781       {
66782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66783       };
66784     }
66785   }
66786
66787   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66788   return jresult;
66789 }
66790
66791
66792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
66793   void * jresult ;
66794   std::string *arg1 = 0 ;
66795   std::string *arg2 = 0 ;
66796   std::string *arg3 = 0 ;
66797   Dali::Toolkit::Model3dView result;
66798
66799   if (!jarg1) {
66800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66801     return 0;
66802   }
66803   std::string arg1_str(jarg1);
66804   arg1 = &arg1_str;
66805   if (!jarg2) {
66806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66807     return 0;
66808   }
66809   std::string arg2_str(jarg2);
66810   arg2 = &arg2_str;
66811   if (!jarg3) {
66812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66813     return 0;
66814   }
66815   std::string arg3_str(jarg3);
66816   arg3 = &arg3_str;
66817   {
66818     try {
66819       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
66820     } catch (std::out_of_range& e) {
66821       {
66822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66823       };
66824     } catch (std::exception& e) {
66825       {
66826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66827       };
66828     } catch (Dali::DaliException e) {
66829       {
66830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66831       };
66832     } catch (...) {
66833       {
66834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66835       };
66836     }
66837   }
66838
66839   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66840
66841   //argout typemap for const std::string&
66842
66843
66844   //argout typemap for const std::string&
66845
66846
66847   //argout typemap for const std::string&
66848
66849   return jresult;
66850 }
66851
66852
66853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
66854   void * jresult ;
66855   Dali::Toolkit::Model3dView *result = 0 ;
66856
66857   {
66858     try {
66859       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
66860     } catch (std::out_of_range& e) {
66861       {
66862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66863       };
66864     } catch (std::exception& e) {
66865       {
66866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66867       };
66868     } catch (Dali::DaliException e) {
66869       {
66870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66871       };
66872     } catch (...) {
66873       {
66874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66875       };
66876     }
66877   }
66878
66879   jresult = (void *)result;
66880   return jresult;
66881 }
66882
66883
66884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
66885   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66886
66887   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66888   {
66889     try {
66890       delete arg1;
66891     } catch (std::out_of_range& e) {
66892       {
66893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66894       };
66895     } catch (std::exception& e) {
66896       {
66897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66898       };
66899     } catch (Dali::DaliException e) {
66900       {
66901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66902       };
66903     } catch (...) {
66904       {
66905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66906       };
66907     }
66908   }
66909
66910 }
66911
66912
66913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
66914   void * jresult ;
66915   Dali::Toolkit::Model3dView *arg1 = 0 ;
66916   Dali::Toolkit::Model3dView *result = 0 ;
66917
66918   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66919   if (!arg1) {
66920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66921     return 0;
66922   }
66923   {
66924     try {
66925       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
66926     } catch (std::out_of_range& e) {
66927       {
66928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66929       };
66930     } catch (std::exception& e) {
66931       {
66932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66933       };
66934     } catch (Dali::DaliException e) {
66935       {
66936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66937       };
66938     } catch (...) {
66939       {
66940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66941       };
66942     }
66943   }
66944
66945   jresult = (void *)result;
66946   return jresult;
66947 }
66948
66949
66950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
66951   void * jresult ;
66952   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
66953   Dali::Toolkit::Model3dView *arg2 = 0 ;
66954   Dali::Toolkit::Model3dView *result = 0 ;
66955
66956   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
66957   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
66958   if (!arg2) {
66959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
66960     return 0;
66961   }
66962   {
66963     try {
66964       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
66965     } catch (std::out_of_range& e) {
66966       {
66967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66968       };
66969     } catch (std::exception& e) {
66970       {
66971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66972       };
66973     } catch (Dali::DaliException e) {
66974       {
66975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66976       };
66977     } catch (...) {
66978       {
66979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66980       };
66981     }
66982   }
66983
66984   jresult = (void *)result;
66985   return jresult;
66986 }
66987
66988
66989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
66990   void * jresult ;
66991   Dali::BaseHandle arg1 ;
66992   Dali::BaseHandle *argp1 ;
66993   Dali::Toolkit::Model3dView result;
66994
66995   argp1 = (Dali::BaseHandle *)jarg1;
66996   if (!argp1) {
66997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66998     return 0;
66999   }
67000   arg1 = *argp1;
67001   {
67002     try {
67003       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67004     } catch (std::out_of_range& e) {
67005       {
67006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67007       };
67008     } catch (std::exception& e) {
67009       {
67010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67011       };
67012     } catch (Dali::DaliException e) {
67013       {
67014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67015       };
67016     } catch (...) {
67017       {
67018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67019       };
67020     }
67021   }
67022
67023   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67024   return jresult;
67025 }
67026
67027
67028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67029   int jresult ;
67030   int result;
67031
67032   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67033   jresult = (int)result;
67034   return jresult;
67035 }
67036
67037
67038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67039   int jresult ;
67040   int result;
67041
67042   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67043   jresult = (int)result;
67044   return jresult;
67045 }
67046
67047
67048 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67049   int jresult ;
67050   int result;
67051
67052   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67053   jresult = (int)result;
67054   return jresult;
67055 }
67056
67057
67058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67059   int jresult ;
67060   int result;
67061
67062   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67063   jresult = (int)result;
67064   return jresult;
67065 }
67066
67067
67068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67069   int jresult ;
67070   int result;
67071
67072   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67073   jresult = (int)result;
67074   return jresult;
67075 }
67076
67077
67078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67079   int jresult ;
67080   int result;
67081
67082   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67083   jresult = (int)result;
67084   return jresult;
67085 }
67086
67087
67088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67089   int jresult ;
67090   int result;
67091
67092   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67093   jresult = (int)result;
67094   return jresult;
67095 }
67096
67097
67098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67099   int jresult ;
67100   int result;
67101
67102   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67103   jresult = (int)result;
67104   return jresult;
67105 }
67106
67107
67108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67109   int jresult ;
67110   int result;
67111
67112   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67113   jresult = (int)result;
67114   return jresult;
67115 }
67116
67117
67118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67119   void * jresult ;
67120   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67121
67122   {
67123     try {
67124       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67125     } catch (std::out_of_range& e) {
67126       {
67127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67128       };
67129     } catch (std::exception& e) {
67130       {
67131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67132       };
67133     } catch (Dali::DaliException e) {
67134       {
67135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67136       };
67137     } catch (...) {
67138       {
67139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67140       };
67141     }
67142   }
67143
67144   jresult = (void *)result;
67145   return jresult;
67146 }
67147
67148
67149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67150   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67151
67152   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67153   {
67154     try {
67155       delete arg1;
67156     } catch (std::out_of_range& e) {
67157       {
67158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67159       };
67160     } catch (std::exception& e) {
67161       {
67162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67163       };
67164     } catch (Dali::DaliException e) {
67165       {
67166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67167       };
67168     } catch (...) {
67169       {
67170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67171       };
67172     }
67173   }
67174
67175 }
67176
67177
67178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
67179   void * jresult ;
67180   Dali::Toolkit::ScrollBar *result = 0 ;
67181
67182   {
67183     try {
67184       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67185     } catch (std::out_of_range& e) {
67186       {
67187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67188       };
67189     } catch (std::exception& e) {
67190       {
67191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67192       };
67193     } catch (Dali::DaliException e) {
67194       {
67195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67196       };
67197     } catch (...) {
67198       {
67199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67200       };
67201     }
67202   }
67203
67204   jresult = (void *)result;
67205   return jresult;
67206 }
67207
67208
67209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
67210   void * jresult ;
67211   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67212   Dali::Toolkit::ScrollBar *result = 0 ;
67213
67214   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67215   if (!arg1) {
67216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67217     return 0;
67218   }
67219   {
67220     try {
67221       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
67222     } catch (std::out_of_range& e) {
67223       {
67224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67225       };
67226     } catch (std::exception& e) {
67227       {
67228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67229       };
67230     } catch (Dali::DaliException e) {
67231       {
67232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67233       };
67234     } catch (...) {
67235       {
67236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67237       };
67238     }
67239   }
67240
67241   jresult = (void *)result;
67242   return jresult;
67243 }
67244
67245
67246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
67247   void * jresult ;
67248   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67249   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67250   Dali::Toolkit::ScrollBar *result = 0 ;
67251
67252   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67253   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67254   if (!arg2) {
67255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67256     return 0;
67257   }
67258   {
67259     try {
67260       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67261     } catch (std::out_of_range& e) {
67262       {
67263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67264       };
67265     } catch (std::exception& e) {
67266       {
67267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67268       };
67269     } catch (Dali::DaliException e) {
67270       {
67271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67272       };
67273     } catch (...) {
67274       {
67275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67276       };
67277     }
67278   }
67279
67280   jresult = (void *)result;
67281   return jresult;
67282 }
67283
67284
67285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67286   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67287
67288   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67289   {
67290     try {
67291       delete arg1;
67292     } catch (std::out_of_range& e) {
67293       {
67294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67295       };
67296     } catch (std::exception& e) {
67297       {
67298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67299       };
67300     } catch (Dali::DaliException e) {
67301       {
67302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67303       };
67304     } catch (...) {
67305       {
67306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67307       };
67308     }
67309   }
67310
67311 }
67312
67313
67314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67315   void * jresult ;
67316   Dali::Toolkit::ScrollBar::Direction arg1 ;
67317   Dali::Toolkit::ScrollBar result;
67318
67319   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67320   {
67321     try {
67322       result = Dali::Toolkit::ScrollBar::New(arg1);
67323     } catch (std::out_of_range& e) {
67324       {
67325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67326       };
67327     } catch (std::exception& e) {
67328       {
67329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67330       };
67331     } catch (Dali::DaliException e) {
67332       {
67333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67334       };
67335     } catch (...) {
67336       {
67337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67338       };
67339     }
67340   }
67341
67342   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67343   return jresult;
67344 }
67345
67346
67347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67348   void * jresult ;
67349   Dali::Toolkit::ScrollBar result;
67350
67351   {
67352     try {
67353       result = Dali::Toolkit::ScrollBar::New();
67354     } catch (std::out_of_range& e) {
67355       {
67356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67357       };
67358     } catch (std::exception& e) {
67359       {
67360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67361       };
67362     } catch (Dali::DaliException e) {
67363       {
67364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67365       };
67366     } catch (...) {
67367       {
67368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67369       };
67370     }
67371   }
67372
67373   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67374   return jresult;
67375 }
67376
67377
67378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67379   void * jresult ;
67380   Dali::BaseHandle arg1 ;
67381   Dali::BaseHandle *argp1 ;
67382   Dali::Toolkit::ScrollBar result;
67383
67384   argp1 = (Dali::BaseHandle *)jarg1;
67385   if (!argp1) {
67386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67387     return 0;
67388   }
67389   arg1 = *argp1;
67390   {
67391     try {
67392       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67393     } catch (std::out_of_range& e) {
67394       {
67395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67396       };
67397     } catch (std::exception& e) {
67398       {
67399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67400       };
67401     } catch (Dali::DaliException e) {
67402       {
67403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67404       };
67405     } catch (...) {
67406       {
67407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67408       };
67409     }
67410   }
67411
67412   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67413   return jresult;
67414 }
67415
67416
67417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67418   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67419   Dali::Handle arg2 ;
67420   Dali::Property::Index arg3 ;
67421   Dali::Property::Index arg4 ;
67422   Dali::Property::Index arg5 ;
67423   Dali::Property::Index arg6 ;
67424   Dali::Handle *argp2 ;
67425
67426   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67427   argp2 = (Dali::Handle *)jarg2;
67428   if (!argp2) {
67429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67430     return ;
67431   }
67432   arg2 = *argp2;
67433   arg3 = (Dali::Property::Index)jarg3;
67434   arg4 = (Dali::Property::Index)jarg4;
67435   arg5 = (Dali::Property::Index)jarg5;
67436   arg6 = (Dali::Property::Index)jarg6;
67437   {
67438     try {
67439       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67440     } catch (std::out_of_range& e) {
67441       {
67442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67443       };
67444     } catch (std::exception& e) {
67445       {
67446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67447       };
67448     } catch (Dali::DaliException e) {
67449       {
67450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67451       };
67452     } catch (...) {
67453       {
67454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67455       };
67456     }
67457   }
67458
67459 }
67460
67461
67462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67463   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67464   Dali::Actor arg2 ;
67465   Dali::Actor *argp2 ;
67466
67467   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67468   argp2 = (Dali::Actor *)jarg2;
67469   if (!argp2) {
67470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67471     return ;
67472   }
67473   arg2 = *argp2;
67474   {
67475     try {
67476       (arg1)->SetScrollIndicator(arg2);
67477     } catch (std::out_of_range& e) {
67478       {
67479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67480       };
67481     } catch (std::exception& e) {
67482       {
67483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67484       };
67485     } catch (Dali::DaliException e) {
67486       {
67487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67488       };
67489     } catch (...) {
67490       {
67491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67492       };
67493     }
67494   }
67495
67496 }
67497
67498
67499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
67500   void * jresult ;
67501   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67502   Dali::Actor result;
67503
67504   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67505   {
67506     try {
67507       result = (arg1)->GetScrollIndicator();
67508     } catch (std::out_of_range& e) {
67509       {
67510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67511       };
67512     } catch (std::exception& e) {
67513       {
67514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67515       };
67516     } catch (Dali::DaliException e) {
67517       {
67518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67519       };
67520     } catch (...) {
67521       {
67522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67523       };
67524     }
67525   }
67526
67527   jresult = new Dali::Actor((const Dali::Actor &)result);
67528   return jresult;
67529 }
67530
67531
67532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
67533   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67534   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
67535
67536   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67537   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
67538   if (!arg2) {
67539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
67540     return ;
67541   }
67542   {
67543     try {
67544       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
67545     } catch (std::out_of_range& e) {
67546       {
67547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67548       };
67549     } catch (std::exception& e) {
67550       {
67551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67552       };
67553     } catch (Dali::DaliException e) {
67554       {
67555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67556       };
67557     } catch (...) {
67558       {
67559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67560       };
67561     }
67562   }
67563
67564 }
67565
67566
67567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
67568   void * jresult ;
67569   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67570
67571   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67572   {
67573     try {
67574       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()));
67575     } catch (std::out_of_range& e) {
67576       {
67577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67578       };
67579     } catch (std::exception& e) {
67580       {
67581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67582       };
67583     } catch (...) {
67584       {
67585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67586       };
67587     }
67588   }
67589   return jresult;
67590 }
67591
67592
67593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
67594   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67595   Dali::Toolkit::ScrollBar::Direction arg2 ;
67596
67597   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67598   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
67599   {
67600     try {
67601       (arg1)->SetScrollDirection(arg2);
67602     } catch (std::out_of_range& e) {
67603       {
67604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67605       };
67606     } catch (std::exception& e) {
67607       {
67608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67609       };
67610     } catch (Dali::DaliException e) {
67611       {
67612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67613       };
67614     } catch (...) {
67615       {
67616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67617       };
67618     }
67619   }
67620
67621 }
67622
67623
67624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
67625   int jresult ;
67626   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67627   Dali::Toolkit::ScrollBar::Direction result;
67628
67629   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67630   {
67631     try {
67632       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
67633     } catch (std::out_of_range& e) {
67634       {
67635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67636       };
67637     } catch (std::exception& e) {
67638       {
67639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67640       };
67641     } catch (Dali::DaliException e) {
67642       {
67643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67644       };
67645     } catch (...) {
67646       {
67647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67648       };
67649     }
67650   }
67651
67652   jresult = (int)result;
67653   return jresult;
67654 }
67655
67656
67657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
67658   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67659   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
67660
67661   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67662   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
67663   {
67664     try {
67665       (arg1)->SetIndicatorHeightPolicy(arg2);
67666     } catch (std::out_of_range& e) {
67667       {
67668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67669       };
67670     } catch (std::exception& e) {
67671       {
67672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67673       };
67674     } catch (Dali::DaliException e) {
67675       {
67676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67677       };
67678     } catch (...) {
67679       {
67680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67681       };
67682     }
67683   }
67684
67685 }
67686
67687
67688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
67689   int jresult ;
67690   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67691   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
67692
67693   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67694   {
67695     try {
67696       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
67697     } catch (std::out_of_range& e) {
67698       {
67699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67700       };
67701     } catch (std::exception& e) {
67702       {
67703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67704       };
67705     } catch (Dali::DaliException e) {
67706       {
67707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67708       };
67709     } catch (...) {
67710       {
67711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67712       };
67713     }
67714   }
67715
67716   jresult = (int)result;
67717   return jresult;
67718 }
67719
67720
67721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
67722   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67723   float arg2 ;
67724
67725   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67726   arg2 = (float)jarg2;
67727   {
67728     try {
67729       (arg1)->SetIndicatorFixedHeight(arg2);
67730     } catch (std::out_of_range& e) {
67731       {
67732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67733       };
67734     } catch (std::exception& e) {
67735       {
67736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67737       };
67738     } catch (Dali::DaliException e) {
67739       {
67740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67741       };
67742     } catch (...) {
67743       {
67744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67745       };
67746     }
67747   }
67748
67749 }
67750
67751
67752 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
67753   float jresult ;
67754   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67755   float result;
67756
67757   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67758   {
67759     try {
67760       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
67761     } catch (std::out_of_range& e) {
67762       {
67763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67764       };
67765     } catch (std::exception& e) {
67766       {
67767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67768       };
67769     } catch (Dali::DaliException e) {
67770       {
67771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67772       };
67773     } catch (...) {
67774       {
67775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67776       };
67777     }
67778   }
67779
67780   jresult = result;
67781   return jresult;
67782 }
67783
67784
67785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
67786   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67787   float arg2 ;
67788
67789   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67790   arg2 = (float)jarg2;
67791   {
67792     try {
67793       (arg1)->SetIndicatorShowDuration(arg2);
67794     } catch (std::out_of_range& e) {
67795       {
67796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67797       };
67798     } catch (std::exception& e) {
67799       {
67800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67801       };
67802     } catch (Dali::DaliException e) {
67803       {
67804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67805       };
67806     } catch (...) {
67807       {
67808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67809       };
67810     }
67811   }
67812
67813 }
67814
67815
67816 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
67817   float jresult ;
67818   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67819   float result;
67820
67821   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67822   {
67823     try {
67824       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
67825     } catch (std::out_of_range& e) {
67826       {
67827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67828       };
67829     } catch (std::exception& e) {
67830       {
67831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67832       };
67833     } catch (Dali::DaliException e) {
67834       {
67835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67836       };
67837     } catch (...) {
67838       {
67839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67840       };
67841     }
67842   }
67843
67844   jresult = result;
67845   return jresult;
67846 }
67847
67848
67849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
67850   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67851   float arg2 ;
67852
67853   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67854   arg2 = (float)jarg2;
67855   {
67856     try {
67857       (arg1)->SetIndicatorHideDuration(arg2);
67858     } catch (std::out_of_range& e) {
67859       {
67860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67861       };
67862     } catch (std::exception& e) {
67863       {
67864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67865       };
67866     } catch (Dali::DaliException e) {
67867       {
67868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67869       };
67870     } catch (...) {
67871       {
67872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67873       };
67874     }
67875   }
67876
67877 }
67878
67879
67880 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
67881   float jresult ;
67882   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67883   float result;
67884
67885   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67886   {
67887     try {
67888       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
67889     } catch (std::out_of_range& e) {
67890       {
67891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67892       };
67893     } catch (std::exception& e) {
67894       {
67895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67896       };
67897     } catch (Dali::DaliException e) {
67898       {
67899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67900       };
67901     } catch (...) {
67902       {
67903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67904       };
67905     }
67906   }
67907
67908   jresult = result;
67909   return jresult;
67910 }
67911
67912
67913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
67914   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67915
67916   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67917   {
67918     try {
67919       (arg1)->ShowIndicator();
67920     } catch (std::out_of_range& e) {
67921       {
67922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67923       };
67924     } catch (std::exception& e) {
67925       {
67926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67927       };
67928     } catch (Dali::DaliException e) {
67929       {
67930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67931       };
67932     } catch (...) {
67933       {
67934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67935       };
67936     }
67937   }
67938
67939 }
67940
67941
67942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
67943   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67944
67945   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67946   {
67947     try {
67948       (arg1)->HideIndicator();
67949     } catch (std::out_of_range& e) {
67950       {
67951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67952       };
67953     } catch (std::exception& e) {
67954       {
67955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67956       };
67957     } catch (Dali::DaliException e) {
67958       {
67959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67960       };
67961     } catch (...) {
67962       {
67963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67964       };
67965     }
67966   }
67967
67968 }
67969
67970
67971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
67972   void * jresult ;
67973   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67974   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
67975
67976   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67977   {
67978     try {
67979       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
67980     } catch (std::out_of_range& e) {
67981       {
67982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67983       };
67984     } catch (std::exception& e) {
67985       {
67986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67987       };
67988     } catch (Dali::DaliException e) {
67989       {
67990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67991       };
67992     } catch (...) {
67993       {
67994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67995       };
67996     }
67997   }
67998
67999   jresult = (void *)result;
68000   return jresult;
68001 }
68002
68003
68004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68005   void * jresult ;
68006   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68007   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68008
68009   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68010   {
68011     try {
68012       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68013     } catch (std::out_of_range& e) {
68014       {
68015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68016       };
68017     } catch (std::exception& e) {
68018       {
68019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68020       };
68021     } catch (Dali::DaliException e) {
68022       {
68023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68024       };
68025     } catch (...) {
68026       {
68027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68028       };
68029     }
68030   }
68031
68032   jresult = (void *)result;
68033   return jresult;
68034 }
68035
68036
68037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68038   int jresult ;
68039   int result;
68040
68041   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68042   jresult = (int)result;
68043   return jresult;
68044 }
68045
68046
68047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68048   int jresult ;
68049   int result;
68050
68051   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68052   jresult = (int)result;
68053   return jresult;
68054 }
68055
68056
68057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68058   int jresult ;
68059   int result;
68060
68061   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68062   jresult = (int)result;
68063   return jresult;
68064 }
68065
68066
68067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68068   int jresult ;
68069   int result;
68070
68071   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68072   jresult = (int)result;
68073   return jresult;
68074 }
68075
68076
68077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68078   int jresult ;
68079   int result;
68080
68081   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68082   jresult = (int)result;
68083   return jresult;
68084 }
68085
68086
68087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68088   int jresult ;
68089   int result;
68090
68091   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68092   jresult = (int)result;
68093   return jresult;
68094 }
68095
68096
68097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68098   int jresult ;
68099   int result;
68100
68101   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68102   jresult = (int)result;
68103   return jresult;
68104 }
68105
68106
68107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68108   int jresult ;
68109   int result;
68110
68111   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68112   jresult = (int)result;
68113   return jresult;
68114 }
68115
68116
68117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68118   int jresult ;
68119   int result;
68120
68121   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68122   jresult = (int)result;
68123   return jresult;
68124 }
68125
68126
68127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68128   int jresult ;
68129   int result;
68130
68131   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68132   jresult = (int)result;
68133   return jresult;
68134 }
68135
68136
68137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68138   int jresult ;
68139   int result;
68140
68141   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68142   jresult = (int)result;
68143   return jresult;
68144 }
68145
68146
68147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68148   int jresult ;
68149   int result;
68150
68151   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68152   jresult = (int)result;
68153   return jresult;
68154 }
68155
68156
68157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68158   int jresult ;
68159   int result;
68160
68161   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68162   jresult = (int)result;
68163   return jresult;
68164 }
68165
68166
68167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68168   int jresult ;
68169   int result;
68170
68171   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68172   jresult = (int)result;
68173   return jresult;
68174 }
68175
68176
68177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
68178   void * jresult ;
68179   Dali::Toolkit::Scrollable::Property *result = 0 ;
68180
68181   {
68182     try {
68183       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68184     } catch (std::out_of_range& e) {
68185       {
68186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68187       };
68188     } catch (std::exception& e) {
68189       {
68190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68191       };
68192     } catch (Dali::DaliException e) {
68193       {
68194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68195       };
68196     } catch (...) {
68197       {
68198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68199       };
68200     }
68201   }
68202
68203   jresult = (void *)result;
68204   return jresult;
68205 }
68206
68207
68208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
68209   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68210
68211   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68212   {
68213     try {
68214       delete arg1;
68215     } catch (std::out_of_range& e) {
68216       {
68217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68218       };
68219     } catch (std::exception& e) {
68220       {
68221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68222       };
68223     } catch (Dali::DaliException e) {
68224       {
68225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68226       };
68227     } catch (...) {
68228       {
68229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68230       };
68231     }
68232   }
68233
68234 }
68235
68236
68237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68238   void * jresult ;
68239   Dali::Toolkit::Scrollable *result = 0 ;
68240
68241   {
68242     try {
68243       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68244     } catch (std::out_of_range& e) {
68245       {
68246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68247       };
68248     } catch (std::exception& e) {
68249       {
68250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68251       };
68252     } catch (Dali::DaliException e) {
68253       {
68254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68255       };
68256     } catch (...) {
68257       {
68258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68259       };
68260     }
68261   }
68262
68263   jresult = (void *)result;
68264   return jresult;
68265 }
68266
68267
68268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68269   void * jresult ;
68270   Dali::Toolkit::Scrollable *arg1 = 0 ;
68271   Dali::Toolkit::Scrollable *result = 0 ;
68272
68273   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68274   if (!arg1) {
68275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68276     return 0;
68277   }
68278   {
68279     try {
68280       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68281     } catch (std::out_of_range& e) {
68282       {
68283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68284       };
68285     } catch (std::exception& e) {
68286       {
68287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68288       };
68289     } catch (Dali::DaliException e) {
68290       {
68291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68292       };
68293     } catch (...) {
68294       {
68295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68296       };
68297     }
68298   }
68299
68300   jresult = (void *)result;
68301   return jresult;
68302 }
68303
68304
68305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
68306   void * jresult ;
68307   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68308   Dali::Toolkit::Scrollable *arg2 = 0 ;
68309   Dali::Toolkit::Scrollable *result = 0 ;
68310
68311   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68312   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
68313   if (!arg2) {
68314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68315     return 0;
68316   }
68317   {
68318     try {
68319       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
68320     } catch (std::out_of_range& e) {
68321       {
68322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68323       };
68324     } catch (std::exception& e) {
68325       {
68326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68327       };
68328     } catch (Dali::DaliException e) {
68329       {
68330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68331       };
68332     } catch (...) {
68333       {
68334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68335       };
68336     }
68337   }
68338
68339   jresult = (void *)result;
68340   return jresult;
68341 }
68342
68343
68344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
68345   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68346
68347   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68348   {
68349     try {
68350       delete arg1;
68351     } catch (std::out_of_range& e) {
68352       {
68353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68354       };
68355     } catch (std::exception& e) {
68356       {
68357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68358       };
68359     } catch (Dali::DaliException e) {
68360       {
68361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68362       };
68363     } catch (...) {
68364       {
68365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68366       };
68367     }
68368   }
68369
68370 }
68371
68372
68373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
68374   void * jresult ;
68375   Dali::BaseHandle arg1 ;
68376   Dali::BaseHandle *argp1 ;
68377   Dali::Toolkit::Scrollable result;
68378
68379   argp1 = (Dali::BaseHandle *)jarg1;
68380   if (!argp1) {
68381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68382     return 0;
68383   }
68384   arg1 = *argp1;
68385   {
68386     try {
68387       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68388     } catch (std::out_of_range& e) {
68389       {
68390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68391       };
68392     } catch (std::exception& e) {
68393       {
68394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68395       };
68396     } catch (Dali::DaliException e) {
68397       {
68398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68399       };
68400     } catch (...) {
68401       {
68402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68403       };
68404     }
68405   }
68406
68407   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68408   return jresult;
68409 }
68410
68411
68412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68413   unsigned int jresult ;
68414   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68415   bool result;
68416
68417   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68418   {
68419     try {
68420       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68421     } catch (std::out_of_range& e) {
68422       {
68423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68424       };
68425     } catch (std::exception& e) {
68426       {
68427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68428       };
68429     } catch (Dali::DaliException e) {
68430       {
68431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68432       };
68433     } catch (...) {
68434       {
68435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68436       };
68437     }
68438   }
68439
68440   jresult = result;
68441   return jresult;
68442 }
68443
68444
68445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68446   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68447   bool arg2 ;
68448
68449   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68450   arg2 = jarg2 ? true : false;
68451   {
68452     try {
68453       (arg1)->SetOvershootEnabled(arg2);
68454     } catch (std::out_of_range& e) {
68455       {
68456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68457       };
68458     } catch (std::exception& e) {
68459       {
68460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68461       };
68462     } catch (Dali::DaliException e) {
68463       {
68464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68465       };
68466     } catch (...) {
68467       {
68468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68469       };
68470     }
68471   }
68472
68473 }
68474
68475
68476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68477   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68478   Dali::Vector4 *arg2 = 0 ;
68479
68480   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68481   arg2 = (Dali::Vector4 *)jarg2;
68482   if (!arg2) {
68483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68484     return ;
68485   }
68486   {
68487     try {
68488       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68489     } catch (std::out_of_range& e) {
68490       {
68491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68492       };
68493     } catch (std::exception& e) {
68494       {
68495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68496       };
68497     } catch (Dali::DaliException e) {
68498       {
68499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68500       };
68501     } catch (...) {
68502       {
68503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68504       };
68505     }
68506   }
68507
68508 }
68509
68510
68511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
68512   void * jresult ;
68513   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68514   Dali::Vector4 result;
68515
68516   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68517   {
68518     try {
68519       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68520     } catch (std::out_of_range& e) {
68521       {
68522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68523       };
68524     } catch (std::exception& e) {
68525       {
68526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68527       };
68528     } catch (Dali::DaliException e) {
68529       {
68530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68531       };
68532     } catch (...) {
68533       {
68534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68535       };
68536     }
68537   }
68538
68539   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68540   return jresult;
68541 }
68542
68543
68544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68545   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68546   float arg2 ;
68547
68548   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68549   arg2 = (float)jarg2;
68550   {
68551     try {
68552       (arg1)->SetOvershootAnimationSpeed(arg2);
68553     } catch (std::out_of_range& e) {
68554       {
68555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68556       };
68557     } catch (std::exception& e) {
68558       {
68559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68560       };
68561     } catch (Dali::DaliException e) {
68562       {
68563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68564       };
68565     } catch (...) {
68566       {
68567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68568       };
68569     }
68570   }
68571
68572 }
68573
68574
68575 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
68576   float jresult ;
68577   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68578   float result;
68579
68580   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68581   {
68582     try {
68583       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
68584     } catch (std::out_of_range& e) {
68585       {
68586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68587       };
68588     } catch (std::exception& e) {
68589       {
68590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68591       };
68592     } catch (Dali::DaliException e) {
68593       {
68594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68595       };
68596     } catch (...) {
68597       {
68598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68599       };
68600     }
68601   }
68602
68603   jresult = result;
68604   return jresult;
68605 }
68606
68607
68608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
68609   void * jresult ;
68610   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68611   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
68612
68613   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68614   {
68615     try {
68616       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
68617     } catch (std::out_of_range& e) {
68618       {
68619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68620       };
68621     } catch (std::exception& e) {
68622       {
68623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68624       };
68625     } catch (Dali::DaliException e) {
68626       {
68627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68628       };
68629     } catch (...) {
68630       {
68631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68632       };
68633     }
68634   }
68635
68636   jresult = (void *)result;
68637   return jresult;
68638 }
68639
68640
68641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
68642   void * jresult ;
68643   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68644   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
68645
68646   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68647   {
68648     try {
68649       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
68650     } catch (std::out_of_range& e) {
68651       {
68652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68653       };
68654     } catch (std::exception& e) {
68655       {
68656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68657       };
68658     } catch (Dali::DaliException e) {
68659       {
68660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68661       };
68662     } catch (...) {
68663       {
68664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68665       };
68666     }
68667   }
68668
68669   jresult = (void *)result;
68670   return jresult;
68671 }
68672
68673
68674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
68675   void * jresult ;
68676   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68677   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
68678
68679   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68680   {
68681     try {
68682       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
68683     } catch (std::out_of_range& e) {
68684       {
68685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68686       };
68687     } catch (std::exception& e) {
68688       {
68689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68690       };
68691     } catch (Dali::DaliException e) {
68692       {
68693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68694       };
68695     } catch (...) {
68696       {
68697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68698       };
68699     }
68700   }
68701
68702   jresult = (void *)result;
68703   return jresult;
68704 }
68705
68706
68707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
68708   unsigned int jresult ;
68709   Dali::Toolkit::ControlOrientation::Type arg1 ;
68710   bool result;
68711
68712   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68713   {
68714     try {
68715       result = (bool)Dali::Toolkit::IsVertical(arg1);
68716     } catch (std::out_of_range& e) {
68717       {
68718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68719       };
68720     } catch (std::exception& e) {
68721       {
68722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68723       };
68724     } catch (Dali::DaliException e) {
68725       {
68726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68727       };
68728     } catch (...) {
68729       {
68730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68731       };
68732     }
68733   }
68734
68735   jresult = result;
68736   return jresult;
68737 }
68738
68739
68740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
68741   unsigned int jresult ;
68742   Dali::Toolkit::ControlOrientation::Type arg1 ;
68743   bool result;
68744
68745   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68746   {
68747     try {
68748       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
68749     } catch (std::out_of_range& e) {
68750       {
68751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68752       };
68753     } catch (std::exception& e) {
68754       {
68755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68756       };
68757     } catch (Dali::DaliException e) {
68758       {
68759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68760       };
68761     } catch (...) {
68762       {
68763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68764       };
68765     }
68766   }
68767
68768   jresult = result;
68769   return jresult;
68770 }
68771
68772
68773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
68774   void * jresult ;
68775   unsigned int arg1 ;
68776   unsigned int arg2 ;
68777   Dali::Toolkit::ItemRange *result = 0 ;
68778
68779   arg1 = (unsigned int)jarg1;
68780   arg2 = (unsigned int)jarg2;
68781   {
68782     try {
68783       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
68784     } catch (std::out_of_range& e) {
68785       {
68786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68787       };
68788     } catch (std::exception& e) {
68789       {
68790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68791       };
68792     } catch (Dali::DaliException e) {
68793       {
68794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68795       };
68796     } catch (...) {
68797       {
68798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68799       };
68800     }
68801   }
68802
68803   jresult = (void *)result;
68804   return jresult;
68805 }
68806
68807
68808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
68809   void * jresult ;
68810   Dali::Toolkit::ItemRange *arg1 = 0 ;
68811   Dali::Toolkit::ItemRange *result = 0 ;
68812
68813   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68814   if (!arg1) {
68815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68816     return 0;
68817   }
68818   {
68819     try {
68820       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
68821     } catch (std::out_of_range& e) {
68822       {
68823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68824       };
68825     } catch (std::exception& e) {
68826       {
68827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68828       };
68829     } catch (Dali::DaliException e) {
68830       {
68831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68832       };
68833     } catch (...) {
68834       {
68835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68836       };
68837     }
68838   }
68839
68840   jresult = (void *)result;
68841   return jresult;
68842 }
68843
68844
68845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
68846   void * jresult ;
68847   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68848   Dali::Toolkit::ItemRange *arg2 = 0 ;
68849   Dali::Toolkit::ItemRange *result = 0 ;
68850
68851   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68852   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68853   if (!arg2) {
68854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68855     return 0;
68856   }
68857   {
68858     try {
68859       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
68860     } catch (std::out_of_range& e) {
68861       {
68862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68863       };
68864     } catch (std::exception& e) {
68865       {
68866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68867       };
68868     } catch (Dali::DaliException e) {
68869       {
68870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68871       };
68872     } catch (...) {
68873       {
68874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68875       };
68876     }
68877   }
68878
68879   jresult = (void *)result;
68880   return jresult;
68881 }
68882
68883
68884 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
68885   unsigned int jresult ;
68886   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68887   unsigned int arg2 ;
68888   bool result;
68889
68890   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68891   arg2 = (unsigned int)jarg2;
68892   {
68893     try {
68894       result = (bool)(arg1)->Within(arg2);
68895     } catch (std::out_of_range& e) {
68896       {
68897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68898       };
68899     } catch (std::exception& e) {
68900       {
68901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68902       };
68903     } catch (Dali::DaliException e) {
68904       {
68905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68906       };
68907     } catch (...) {
68908       {
68909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68910       };
68911     }
68912   }
68913
68914   jresult = result;
68915   return jresult;
68916 }
68917
68918
68919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
68920   void * jresult ;
68921   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68922   Dali::Toolkit::ItemRange *arg2 = 0 ;
68923   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
68924
68925   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68926   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
68927   if (!arg2) {
68928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68929     return 0;
68930   }
68931   {
68932     try {
68933       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
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::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
68954   return jresult;
68955 }
68956
68957
68958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
68959   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68960   unsigned int arg2 ;
68961
68962   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68963   arg2 = (unsigned int)jarg2;
68964   if (arg1) (arg1)->begin = arg2;
68965 }
68966
68967
68968 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
68969   unsigned int jresult ;
68970   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68971   unsigned int result;
68972
68973   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68974   result = (unsigned int) ((arg1)->begin);
68975   jresult = result;
68976   return jresult;
68977 }
68978
68979
68980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
68981   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68982   unsigned int arg2 ;
68983
68984   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68985   arg2 = (unsigned int)jarg2;
68986   if (arg1) (arg1)->end = arg2;
68987 }
68988
68989
68990 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
68991   unsigned int jresult ;
68992   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
68993   unsigned int result;
68994
68995   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68996   result = (unsigned int) ((arg1)->end);
68997   jresult = result;
68998   return jresult;
68999 }
69000
69001
69002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69003   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69004
69005   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69006   {
69007     try {
69008       delete arg1;
69009     } catch (std::out_of_range& e) {
69010       {
69011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69012       };
69013     } catch (std::exception& e) {
69014       {
69015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69016       };
69017     } catch (Dali::DaliException e) {
69018       {
69019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69020       };
69021     } catch (...) {
69022       {
69023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69024       };
69025     }
69026   }
69027
69028 }
69029
69030
69031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69032   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69033
69034   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69035   {
69036     try {
69037       delete arg1;
69038     } catch (std::out_of_range& e) {
69039       {
69040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69041       };
69042     } catch (std::exception& e) {
69043       {
69044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69045       };
69046     } catch (Dali::DaliException e) {
69047       {
69048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69049       };
69050     } catch (...) {
69051       {
69052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69053       };
69054     }
69055   }
69056
69057 }
69058
69059
69060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69061   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69062   Dali::Toolkit::ControlOrientation::Type arg2 ;
69063
69064   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69065   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69066   {
69067     try {
69068       (arg1)->SetOrientation(arg2);
69069     } catch (std::out_of_range& e) {
69070       {
69071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69072       };
69073     } catch (std::exception& e) {
69074       {
69075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69076       };
69077     } catch (Dali::DaliException e) {
69078       {
69079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69080       };
69081     } catch (...) {
69082       {
69083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69084       };
69085     }
69086   }
69087
69088 }
69089
69090
69091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69092   int jresult ;
69093   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69094   Dali::Toolkit::ControlOrientation::Type result;
69095
69096   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69097   {
69098     try {
69099       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69100     } catch (std::out_of_range& e) {
69101       {
69102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69103       };
69104     } catch (std::exception& e) {
69105       {
69106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69107       };
69108     } catch (Dali::DaliException e) {
69109       {
69110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69111       };
69112     } catch (...) {
69113       {
69114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69115       };
69116     }
69117   }
69118
69119   jresult = (int)result;
69120   return jresult;
69121 }
69122
69123
69124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69125   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69126   Dali::Property::Map *arg2 = 0 ;
69127
69128   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69129   arg2 = (Dali::Property::Map *)jarg2;
69130   if (!arg2) {
69131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69132     return ;
69133   }
69134   {
69135     try {
69136       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69137     } catch (std::out_of_range& e) {
69138       {
69139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69140       };
69141     } catch (std::exception& e) {
69142       {
69143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69144       };
69145     } catch (Dali::DaliException e) {
69146       {
69147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69148       };
69149     } catch (...) {
69150       {
69151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69152       };
69153     }
69154   }
69155
69156 }
69157
69158
69159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69160   void * jresult ;
69161   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69162   Dali::Property::Map result;
69163
69164   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69165   {
69166     try {
69167       result = (arg1)->GetLayoutProperties();
69168     } catch (std::out_of_range& e) {
69169       {
69170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69171       };
69172     } catch (std::exception& e) {
69173       {
69174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69175       };
69176     } catch (Dali::DaliException e) {
69177       {
69178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69179       };
69180     } catch (...) {
69181       {
69182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69183       };
69184     }
69185   }
69186
69187   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69188   return jresult;
69189 }
69190
69191
69192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69193   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69194   unsigned int arg2 ;
69195   Dali::Vector3 *arg3 = 0 ;
69196   Dali::Vector3 *arg4 = 0 ;
69197
69198   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69199   arg2 = (unsigned int)jarg2;
69200   arg3 = (Dali::Vector3 *)jarg3;
69201   if (!arg3) {
69202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69203     return ;
69204   }
69205   arg4 = (Dali::Vector3 *)jarg4;
69206   if (!arg4) {
69207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69208     return ;
69209   }
69210   {
69211     try {
69212       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69213     } catch (std::out_of_range& e) {
69214       {
69215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69216       };
69217     } catch (std::exception& e) {
69218       {
69219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69220       };
69221     } catch (Dali::DaliException e) {
69222       {
69223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69224       };
69225     } catch (...) {
69226       {
69227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69228       };
69229     }
69230   }
69231
69232 }
69233
69234
69235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69236   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69237   Dali::Vector3 *arg2 = 0 ;
69238
69239   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69240   arg2 = (Dali::Vector3 *)jarg2;
69241   if (!arg2) {
69242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69243     return ;
69244   }
69245   {
69246     try {
69247       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69248     } catch (std::out_of_range& e) {
69249       {
69250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69251       };
69252     } catch (std::exception& e) {
69253       {
69254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69255       };
69256     } catch (Dali::DaliException e) {
69257       {
69258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69259       };
69260     } catch (...) {
69261       {
69262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69263       };
69264     }
69265   }
69266
69267 }
69268
69269
69270 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69271   float jresult ;
69272   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69273   unsigned int arg2 ;
69274   Dali::Vector3 arg3 ;
69275   Dali::Vector3 *argp3 ;
69276   float result;
69277
69278   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69279   arg2 = (unsigned int)jarg2;
69280   argp3 = (Dali::Vector3 *)jarg3;
69281   if (!argp3) {
69282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69283     return 0;
69284   }
69285   arg3 = *argp3;
69286   {
69287     try {
69288       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69289     } catch (std::out_of_range& e) {
69290       {
69291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69292       };
69293     } catch (std::exception& e) {
69294       {
69295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69296       };
69297     } catch (Dali::DaliException e) {
69298       {
69299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69300       };
69301     } catch (...) {
69302       {
69303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69304       };
69305     }
69306   }
69307
69308   jresult = result;
69309   return jresult;
69310 }
69311
69312
69313 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69314   float jresult ;
69315   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69316   float arg2 ;
69317   float result;
69318
69319   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69320   arg2 = (float)jarg2;
69321   {
69322     try {
69323       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69324     } catch (std::out_of_range& e) {
69325       {
69326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69327       };
69328     } catch (std::exception& e) {
69329       {
69330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69331       };
69332     } catch (Dali::DaliException e) {
69333       {
69334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69335       };
69336     } catch (...) {
69337       {
69338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69339       };
69340     }
69341   }
69342
69343   jresult = result;
69344   return jresult;
69345 }
69346
69347
69348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
69349   float jresult ;
69350   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69351   unsigned int arg2 ;
69352   float result;
69353
69354   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69355   arg2 = (unsigned int)jarg2;
69356   {
69357     try {
69358       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
69359     } catch (std::out_of_range& e) {
69360       {
69361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69362       };
69363     } catch (std::exception& e) {
69364       {
69365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69366       };
69367     } catch (Dali::DaliException e) {
69368       {
69369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69370       };
69371     } catch (...) {
69372       {
69373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69374       };
69375     }
69376   }
69377
69378   jresult = result;
69379   return jresult;
69380 }
69381
69382
69383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
69384   void * jresult ;
69385   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69386   float arg2 ;
69387   Dali::Vector3 arg3 ;
69388   Dali::Vector3 *argp3 ;
69389   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69390
69391   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69392   arg2 = (float)jarg2;
69393   argp3 = (Dali::Vector3 *)jarg3;
69394   if (!argp3) {
69395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69396     return 0;
69397   }
69398   arg3 = *argp3;
69399   {
69400     try {
69401       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69402     } catch (std::out_of_range& e) {
69403       {
69404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69405       };
69406     } catch (std::exception& e) {
69407       {
69408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69409       };
69410     } catch (Dali::DaliException e) {
69411       {
69412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69413       };
69414     } catch (...) {
69415       {
69416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69417       };
69418     }
69419   }
69420
69421   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69422   return jresult;
69423 }
69424
69425
69426 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69427   float jresult ;
69428   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69429   int arg2 ;
69430   float arg3 ;
69431   Dali::Vector3 *arg4 = 0 ;
69432   float result;
69433
69434   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69435   arg2 = (int)jarg2;
69436   arg3 = (float)jarg3;
69437   arg4 = (Dali::Vector3 *)jarg4;
69438   if (!arg4) {
69439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69440     return 0;
69441   }
69442   {
69443     try {
69444       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69445     } catch (std::out_of_range& e) {
69446       {
69447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69448       };
69449     } catch (std::exception& e) {
69450       {
69451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69452       };
69453     } catch (Dali::DaliException e) {
69454       {
69455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69456       };
69457     } catch (...) {
69458       {
69459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69460       };
69461     }
69462   }
69463
69464   jresult = result;
69465   return jresult;
69466 }
69467
69468
69469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
69470   unsigned int jresult ;
69471   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69472   Dali::Vector3 arg2 ;
69473   Dali::Vector3 *argp2 ;
69474   unsigned int result;
69475
69476   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69477   argp2 = (Dali::Vector3 *)jarg2;
69478   if (!argp2) {
69479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69480     return 0;
69481   }
69482   arg2 = *argp2;
69483   {
69484     try {
69485       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
69486     } catch (std::out_of_range& e) {
69487       {
69488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69489       };
69490     } catch (std::exception& e) {
69491       {
69492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69493       };
69494     } catch (Dali::DaliException e) {
69495       {
69496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69497       };
69498     } catch (...) {
69499       {
69500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69501       };
69502     }
69503   }
69504
69505   jresult = result;
69506   return jresult;
69507 }
69508
69509
69510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69511   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69512   unsigned int arg2 ;
69513   Dali::Vector3 *arg3 = 0 ;
69514   Dali::Vector3 *arg4 = 0 ;
69515
69516   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69517   arg2 = (unsigned int)jarg2;
69518   arg3 = (Dali::Vector3 *)jarg3;
69519   if (!arg3) {
69520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69521     return ;
69522   }
69523   arg4 = (Dali::Vector3 *)jarg4;
69524   if (!arg4) {
69525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69526     return ;
69527   }
69528   {
69529     try {
69530       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69531     } catch (std::out_of_range& e) {
69532       {
69533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69534       };
69535     } catch (std::exception& e) {
69536       {
69537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69538       };
69539     } catch (Dali::DaliException e) {
69540       {
69541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69542       };
69543     } catch (...) {
69544       {
69545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69546       };
69547     }
69548   }
69549
69550 }
69551
69552
69553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
69554   void * jresult ;
69555   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69556   Dali::Degree result;
69557
69558   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69559   {
69560     try {
69561       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69562     } catch (std::out_of_range& e) {
69563       {
69564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69565       };
69566     } catch (std::exception& e) {
69567       {
69568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69569       };
69570     } catch (Dali::DaliException e) {
69571       {
69572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69573       };
69574     } catch (...) {
69575       {
69576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69577       };
69578     }
69579   }
69580
69581   jresult = new Dali::Degree((const Dali::Degree &)result);
69582   return jresult;
69583 }
69584
69585
69586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
69587   float jresult ;
69588   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69589   float result;
69590
69591   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69592   {
69593     try {
69594       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
69595     } catch (std::out_of_range& e) {
69596       {
69597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69598       };
69599     } catch (std::exception& e) {
69600       {
69601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69602       };
69603     } catch (Dali::DaliException e) {
69604       {
69605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69606       };
69607     } catch (...) {
69608       {
69609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69610       };
69611     }
69612   }
69613
69614   jresult = result;
69615   return jresult;
69616 }
69617
69618
69619 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
69620   float jresult ;
69621   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69622   float result;
69623
69624   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69625   {
69626     try {
69627       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
69628     } catch (std::out_of_range& e) {
69629       {
69630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69631       };
69632     } catch (std::exception& e) {
69633       {
69634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69635       };
69636     } catch (Dali::DaliException e) {
69637       {
69638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69639       };
69640     } catch (...) {
69641       {
69642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69643       };
69644     }
69645   }
69646
69647   jresult = result;
69648   return jresult;
69649 }
69650
69651
69652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
69653   float jresult ;
69654   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69655   float result;
69656
69657   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69658   {
69659     try {
69660       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
69661     } catch (std::out_of_range& e) {
69662       {
69663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69664       };
69665     } catch (std::exception& e) {
69666       {
69667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69668       };
69669     } catch (Dali::DaliException e) {
69670       {
69671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69672       };
69673     } catch (...) {
69674       {
69675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69676       };
69677     }
69678   }
69679
69680   jresult = result;
69681   return jresult;
69682 }
69683
69684
69685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
69686   int jresult ;
69687   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69688   int arg2 ;
69689   int arg3 ;
69690   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
69691   bool arg5 ;
69692   int result;
69693
69694   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69695   arg2 = (int)jarg2;
69696   arg3 = (int)jarg3;
69697   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
69698   arg5 = jarg5 ? true : false;
69699   {
69700     try {
69701       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
69702     } catch (std::out_of_range& e) {
69703       {
69704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69705       };
69706     } catch (std::exception& e) {
69707       {
69708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69709       };
69710     } catch (Dali::DaliException e) {
69711       {
69712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69713       };
69714     } catch (...) {
69715       {
69716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69717       };
69718     }
69719   }
69720
69721   jresult = result;
69722   return jresult;
69723 }
69724
69725
69726 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
69727   float jresult ;
69728   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69729   float result;
69730
69731   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69732   {
69733     try {
69734       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
69735     } catch (std::out_of_range& e) {
69736       {
69737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69738       };
69739     } catch (std::exception& e) {
69740       {
69741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69742       };
69743     } catch (Dali::DaliException e) {
69744       {
69745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69746       };
69747     } catch (...) {
69748       {
69749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69750       };
69751     }
69752   }
69753
69754   jresult = result;
69755   return jresult;
69756 }
69757
69758
69759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
69760   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69761   Dali::Actor *arg2 = 0 ;
69762   int arg3 ;
69763   Dali::Vector3 *arg4 = 0 ;
69764   Dali::Actor *arg5 = 0 ;
69765
69766   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69767   arg2 = (Dali::Actor *)jarg2;
69768   if (!arg2) {
69769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
69770     return ;
69771   }
69772   arg3 = (int)jarg3;
69773   arg4 = (Dali::Vector3 *)jarg4;
69774   if (!arg4) {
69775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69776     return ;
69777   }
69778   arg5 = (Dali::Actor *)jarg5;
69779   if (!arg5) {
69780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
69781     return ;
69782   }
69783   {
69784     try {
69785       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
69786     } catch (std::out_of_range& e) {
69787       {
69788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69789       };
69790     } catch (std::exception& e) {
69791       {
69792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69793       };
69794     } catch (Dali::DaliException e) {
69795       {
69796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69797       };
69798     } catch (...) {
69799       {
69800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69801       };
69802     }
69803   }
69804
69805 }
69806
69807
69808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69809   void * jresult ;
69810   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69811   int arg2 ;
69812   float arg3 ;
69813   Dali::Vector3 *arg4 = 0 ;
69814   Dali::Vector3 result;
69815
69816   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69817   arg2 = (int)jarg2;
69818   arg3 = (float)jarg3;
69819   arg4 = (Dali::Vector3 *)jarg4;
69820   if (!arg4) {
69821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69822     return 0;
69823   }
69824   {
69825     try {
69826       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69827     } catch (std::out_of_range& e) {
69828       {
69829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69830       };
69831     } catch (std::exception& e) {
69832       {
69833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69834       };
69835     } catch (Dali::DaliException e) {
69836       {
69837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69838       };
69839     } catch (...) {
69840       {
69841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69842       };
69843     }
69844   }
69845
69846   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
69847   return jresult;
69848 }
69849
69850
69851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
69852   void * jresult ;
69853   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
69854   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
69855
69856   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
69857   {
69858     try {
69859       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
69860     } catch (std::out_of_range& e) {
69861       {
69862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69863       };
69864     } catch (std::exception& e) {
69865       {
69866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69867       };
69868     } catch (Dali::DaliException e) {
69869       {
69870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69871       };
69872     } catch (...) {
69873       {
69874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69875       };
69876     }
69877   }
69878
69879   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
69880   return jresult;
69881 }
69882
69883
69884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
69885   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69886
69887   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69888   {
69889     try {
69890       delete arg1;
69891     } catch (std::out_of_range& e) {
69892       {
69893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69894       };
69895     } catch (std::exception& e) {
69896       {
69897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69898       };
69899     } catch (Dali::DaliException e) {
69900       {
69901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69902       };
69903     } catch (...) {
69904       {
69905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69906       };
69907     }
69908   }
69909
69910 }
69911
69912
69913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
69914   unsigned int jresult ;
69915   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69916   unsigned int result;
69917
69918   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69919   {
69920     try {
69921       result = (unsigned int)(arg1)->GetNumberOfItems();
69922     } catch (std::out_of_range& e) {
69923       {
69924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69925       };
69926     } catch (std::exception& e) {
69927       {
69928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69929       };
69930     } catch (Dali::DaliException e) {
69931       {
69932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69933       };
69934     } catch (...) {
69935       {
69936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69937       };
69938     }
69939   }
69940
69941   jresult = result;
69942   return jresult;
69943 }
69944
69945
69946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
69947   void * jresult ;
69948   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69949   unsigned int arg2 ;
69950   Dali::Actor result;
69951
69952   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69953   arg2 = (unsigned int)jarg2;
69954   {
69955     try {
69956       result = (arg1)->NewItem(arg2);
69957     } catch (std::out_of_range& e) {
69958       {
69959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69960       };
69961     } catch (std::exception& e) {
69962       {
69963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69964       };
69965     } catch (Dali::DaliException e) {
69966       {
69967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69968       };
69969     } catch (...) {
69970       {
69971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69972       };
69973     }
69974   }
69975
69976   jresult = new Dali::Actor((const Dali::Actor &)result);
69977   return jresult;
69978 }
69979
69980
69981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
69982   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
69983   unsigned int arg2 ;
69984   Dali::Actor arg3 ;
69985   Dali::Actor *argp3 ;
69986
69987   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
69988   arg2 = (unsigned int)jarg2;
69989   argp3 = (Dali::Actor *)jarg3;
69990   if (!argp3) {
69991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69992     return ;
69993   }
69994   arg3 = *argp3;
69995   {
69996     try {
69997       (arg1)->ItemReleased(arg2,arg3);
69998     } catch (std::out_of_range& e) {
69999       {
70000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70001       };
70002     } catch (std::exception& e) {
70003       {
70004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70005       };
70006     } catch (Dali::DaliException e) {
70007       {
70008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70009       };
70010     } catch (...) {
70011       {
70012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70013       };
70014     }
70015   }
70016
70017 }
70018
70019
70020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70021   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70022   unsigned int arg2 ;
70023   Dali::Actor arg3 ;
70024   Dali::Actor *argp3 ;
70025
70026   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70027   arg2 = (unsigned int)jarg2;
70028   argp3 = (Dali::Actor *)jarg3;
70029   if (!argp3) {
70030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70031     return ;
70032   }
70033   arg3 = *argp3;
70034   {
70035     try {
70036       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70037     } catch (std::out_of_range& e) {
70038       {
70039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70040       };
70041     } catch (std::exception& e) {
70042       {
70043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70044       };
70045     } catch (Dali::DaliException e) {
70046       {
70047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70048       };
70049     } catch (...) {
70050       {
70051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70052       };
70053     }
70054   }
70055
70056 }
70057
70058
70059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70060   void * jresult ;
70061   Dali::Toolkit::ItemFactory *result = 0 ;
70062
70063   {
70064     try {
70065       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70066     } catch (std::out_of_range& e) {
70067       {
70068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70069       };
70070     } catch (std::exception& e) {
70071       {
70072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70073       };
70074     } catch (Dali::DaliException e) {
70075       {
70076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70077       };
70078     } catch (...) {
70079       {
70080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70081       };
70082     }
70083   }
70084
70085   jresult = (void *)result;
70086   return jresult;
70087 }
70088
70089
70090 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) {
70091   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70092   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70093   if (director) {
70094     director->swig_connect_director(callback0, callback1, callback2);
70095   }
70096 }
70097
70098
70099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70100   int jresult ;
70101   int result;
70102
70103   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70104   jresult = (int)result;
70105   return jresult;
70106 }
70107
70108
70109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70110   int jresult ;
70111   int result;
70112
70113   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70114   jresult = (int)result;
70115   return jresult;
70116 }
70117
70118
70119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70120   int jresult ;
70121   int result;
70122
70123   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70124   jresult = (int)result;
70125   return jresult;
70126 }
70127
70128
70129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70130   int jresult ;
70131   int result;
70132
70133   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70134   jresult = (int)result;
70135   return jresult;
70136 }
70137
70138
70139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70140   int jresult ;
70141   int result;
70142
70143   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70144   jresult = (int)result;
70145   return jresult;
70146 }
70147
70148
70149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70150   int jresult ;
70151   int result;
70152
70153   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70154   jresult = (int)result;
70155   return jresult;
70156 }
70157
70158
70159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70160   int jresult ;
70161   int result;
70162
70163   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70164   jresult = (int)result;
70165   return jresult;
70166 }
70167
70168
70169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70170   int jresult ;
70171   int result;
70172
70173   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70174   jresult = (int)result;
70175   return jresult;
70176 }
70177
70178
70179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70180   int jresult ;
70181   int result;
70182
70183   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70184   jresult = (int)result;
70185   return jresult;
70186 }
70187
70188
70189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70190   int jresult ;
70191   int result;
70192
70193   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70194   jresult = (int)result;
70195   return jresult;
70196 }
70197
70198
70199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70200   int jresult ;
70201   int result;
70202
70203   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70204   jresult = (int)result;
70205   return jresult;
70206 }
70207
70208
70209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70210   void * jresult ;
70211   Dali::Toolkit::ItemView::Property *result = 0 ;
70212
70213   {
70214     try {
70215       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70216     } catch (std::out_of_range& e) {
70217       {
70218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70219       };
70220     } catch (std::exception& e) {
70221       {
70222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70223       };
70224     } catch (Dali::DaliException e) {
70225       {
70226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70227       };
70228     } catch (...) {
70229       {
70230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70231       };
70232     }
70233   }
70234
70235   jresult = (void *)result;
70236   return jresult;
70237 }
70238
70239
70240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70241   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70242
70243   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70244   {
70245     try {
70246       delete arg1;
70247     } catch (std::out_of_range& e) {
70248       {
70249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70250       };
70251     } catch (std::exception& e) {
70252       {
70253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70254       };
70255     } catch (Dali::DaliException e) {
70256       {
70257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70258       };
70259     } catch (...) {
70260       {
70261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70262       };
70263     }
70264   }
70265
70266 }
70267
70268
70269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70270   void * jresult ;
70271   Dali::Toolkit::ItemView *result = 0 ;
70272
70273   {
70274     try {
70275       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70276     } catch (std::out_of_range& e) {
70277       {
70278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70279       };
70280     } catch (std::exception& e) {
70281       {
70282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70283       };
70284     } catch (Dali::DaliException e) {
70285       {
70286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70287       };
70288     } catch (...) {
70289       {
70290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70291       };
70292     }
70293   }
70294
70295   jresult = (void *)result;
70296   return jresult;
70297 }
70298
70299
70300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70301   void * jresult ;
70302   Dali::Toolkit::ItemView *arg1 = 0 ;
70303   Dali::Toolkit::ItemView *result = 0 ;
70304
70305   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70306   if (!arg1) {
70307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70308     return 0;
70309   }
70310   {
70311     try {
70312       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70313     } catch (std::out_of_range& e) {
70314       {
70315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70316       };
70317     } catch (std::exception& e) {
70318       {
70319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70320       };
70321     } catch (Dali::DaliException e) {
70322       {
70323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70324       };
70325     } catch (...) {
70326       {
70327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70328       };
70329     }
70330   }
70331
70332   jresult = (void *)result;
70333   return jresult;
70334 }
70335
70336
70337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70338   void * jresult ;
70339   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70340   Dali::Toolkit::ItemView *arg2 = 0 ;
70341   Dali::Toolkit::ItemView *result = 0 ;
70342
70343   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70344   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70345   if (!arg2) {
70346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70347     return 0;
70348   }
70349   {
70350     try {
70351       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70352     } catch (std::out_of_range& e) {
70353       {
70354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70355       };
70356     } catch (std::exception& e) {
70357       {
70358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70359       };
70360     } catch (Dali::DaliException e) {
70361       {
70362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70363       };
70364     } catch (...) {
70365       {
70366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70367       };
70368     }
70369   }
70370
70371   jresult = (void *)result;
70372   return jresult;
70373 }
70374
70375
70376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70377   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70378
70379   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70380   {
70381     try {
70382       delete arg1;
70383     } catch (std::out_of_range& e) {
70384       {
70385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70386       };
70387     } catch (std::exception& e) {
70388       {
70389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70390       };
70391     } catch (Dali::DaliException e) {
70392       {
70393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70394       };
70395     } catch (...) {
70396       {
70397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70398       };
70399     }
70400   }
70401
70402 }
70403
70404
70405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70406   void * jresult ;
70407   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70408   Dali::Toolkit::ItemView result;
70409
70410   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70411   if (!arg1) {
70412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70413     return 0;
70414   }
70415   {
70416     try {
70417       result = Dali::Toolkit::ItemView::New(*arg1);
70418     } catch (std::out_of_range& e) {
70419       {
70420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70421       };
70422     } catch (std::exception& e) {
70423       {
70424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70425       };
70426     } catch (Dali::DaliException e) {
70427       {
70428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70429       };
70430     } catch (...) {
70431       {
70432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70433       };
70434     }
70435   }
70436
70437   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70438   return jresult;
70439 }
70440
70441
70442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70443   void * jresult ;
70444   Dali::BaseHandle arg1 ;
70445   Dali::BaseHandle *argp1 ;
70446   Dali::Toolkit::ItemView result;
70447
70448   argp1 = (Dali::BaseHandle *)jarg1;
70449   if (!argp1) {
70450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70451     return 0;
70452   }
70453   arg1 = *argp1;
70454   {
70455     try {
70456       result = Dali::Toolkit::ItemView::DownCast(arg1);
70457     } catch (std::out_of_range& e) {
70458       {
70459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70460       };
70461     } catch (std::exception& e) {
70462       {
70463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70464       };
70465     } catch (Dali::DaliException e) {
70466       {
70467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70468       };
70469     } catch (...) {
70470       {
70471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70472       };
70473     }
70474   }
70475
70476   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70477   return jresult;
70478 }
70479
70480
70481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
70482   unsigned int jresult ;
70483   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70484   unsigned int result;
70485
70486   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70487   {
70488     try {
70489       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
70490     } catch (std::out_of_range& e) {
70491       {
70492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70493       };
70494     } catch (std::exception& e) {
70495       {
70496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70497       };
70498     } catch (Dali::DaliException e) {
70499       {
70500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70501       };
70502     } catch (...) {
70503       {
70504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70505       };
70506     }
70507   }
70508
70509   jresult = result;
70510   return jresult;
70511 }
70512
70513
70514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
70515   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70516   Dali::Toolkit::ItemLayout *arg2 = 0 ;
70517
70518   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70519   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
70520   if (!arg2) {
70521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
70522     return ;
70523   }
70524   {
70525     try {
70526       (arg1)->AddLayout(*arg2);
70527     } catch (std::out_of_range& e) {
70528       {
70529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70530       };
70531     } catch (std::exception& e) {
70532       {
70533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70534       };
70535     } catch (Dali::DaliException e) {
70536       {
70537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70538       };
70539     } catch (...) {
70540       {
70541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70542       };
70543     }
70544   }
70545
70546 }
70547
70548
70549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
70550   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70551   unsigned int arg2 ;
70552
70553   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70554   arg2 = (unsigned int)jarg2;
70555   {
70556     try {
70557       (arg1)->RemoveLayout(arg2);
70558     } catch (std::out_of_range& e) {
70559       {
70560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70561       };
70562     } catch (std::exception& e) {
70563       {
70564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70565       };
70566     } catch (Dali::DaliException e) {
70567       {
70568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70569       };
70570     } catch (...) {
70571       {
70572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70573       };
70574     }
70575   }
70576
70577 }
70578
70579
70580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70581   void * jresult ;
70582   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70583   unsigned int arg2 ;
70584   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70585
70586   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70587   arg2 = (unsigned int)jarg2;
70588   {
70589     try {
70590       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
70591     } catch (std::out_of_range& e) {
70592       {
70593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70594       };
70595     } catch (std::exception& e) {
70596       {
70597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70598       };
70599     } catch (Dali::DaliException e) {
70600       {
70601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70602       };
70603     } catch (...) {
70604       {
70605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70606       };
70607     }
70608   }
70609
70610   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70611   return jresult;
70612 }
70613
70614
70615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
70616   void * jresult ;
70617   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70618   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70619
70620   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70621   {
70622     try {
70623       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
70624     } catch (std::out_of_range& e) {
70625       {
70626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70627       };
70628     } catch (std::exception& e) {
70629       {
70630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70631       };
70632     } catch (Dali::DaliException e) {
70633       {
70634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70635       };
70636     } catch (...) {
70637       {
70638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70639       };
70640     }
70641   }
70642
70643   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70644   return jresult;
70645 }
70646
70647
70648 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
70649   float jresult ;
70650   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70651   Dali::Toolkit::ItemId arg2 ;
70652   float result;
70653
70654   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70655   arg2 = (Dali::Toolkit::ItemId)jarg2;
70656   {
70657     try {
70658       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
70659     } catch (std::out_of_range& e) {
70660       {
70661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70662       };
70663     } catch (std::exception& e) {
70664       {
70665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70666       };
70667     } catch (Dali::DaliException e) {
70668       {
70669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70670       };
70671     } catch (...) {
70672       {
70673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70674       };
70675     }
70676   }
70677
70678   jresult = result;
70679   return jresult;
70680 }
70681
70682
70683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
70684   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70685   unsigned int arg2 ;
70686   Dali::Vector3 arg3 ;
70687   float arg4 ;
70688   Dali::Vector3 *argp3 ;
70689
70690   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70691   arg2 = (unsigned int)jarg2;
70692   argp3 = (Dali::Vector3 *)jarg3;
70693   if (!argp3) {
70694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70695     return ;
70696   }
70697   arg3 = *argp3;
70698   arg4 = (float)jarg4;
70699   {
70700     try {
70701       (arg1)->ActivateLayout(arg2,arg3,arg4);
70702     } catch (std::out_of_range& e) {
70703       {
70704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70705       };
70706     } catch (std::exception& e) {
70707       {
70708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70709       };
70710     } catch (Dali::DaliException e) {
70711       {
70712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70713       };
70714     } catch (...) {
70715       {
70716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70717       };
70718     }
70719   }
70720
70721 }
70722
70723
70724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
70725   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70726
70727   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70728   {
70729     try {
70730       (arg1)->DeactivateCurrentLayout();
70731     } catch (std::out_of_range& e) {
70732       {
70733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70734       };
70735     } catch (std::exception& e) {
70736       {
70737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70738       };
70739     } catch (Dali::DaliException e) {
70740       {
70741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70742       };
70743     } catch (...) {
70744       {
70745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70746       };
70747     }
70748   }
70749
70750 }
70751
70752
70753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
70754   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70755   float arg2 ;
70756
70757   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70758   arg2 = (float)jarg2;
70759   {
70760     try {
70761       (arg1)->SetMinimumSwipeSpeed(arg2);
70762     } catch (std::out_of_range& e) {
70763       {
70764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70765       };
70766     } catch (std::exception& e) {
70767       {
70768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70769       };
70770     } catch (Dali::DaliException e) {
70771       {
70772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70773       };
70774     } catch (...) {
70775       {
70776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70777       };
70778     }
70779   }
70780
70781 }
70782
70783
70784 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
70785   float jresult ;
70786   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70787   float result;
70788
70789   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70790   {
70791     try {
70792       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
70793     } catch (std::out_of_range& e) {
70794       {
70795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70796       };
70797     } catch (std::exception& e) {
70798       {
70799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70800       };
70801     } catch (Dali::DaliException e) {
70802       {
70803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70804       };
70805     } catch (...) {
70806       {
70807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70808       };
70809     }
70810   }
70811
70812   jresult = result;
70813   return jresult;
70814 }
70815
70816
70817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
70818   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70819   float arg2 ;
70820
70821   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70822   arg2 = (float)jarg2;
70823   {
70824     try {
70825       (arg1)->SetMinimumSwipeDistance(arg2);
70826     } catch (std::out_of_range& e) {
70827       {
70828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70829       };
70830     } catch (std::exception& e) {
70831       {
70832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70833       };
70834     } catch (Dali::DaliException e) {
70835       {
70836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70837       };
70838     } catch (...) {
70839       {
70840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70841       };
70842     }
70843   }
70844
70845 }
70846
70847
70848 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
70849   float jresult ;
70850   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70851   float result;
70852
70853   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70854   {
70855     try {
70856       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
70857     } catch (std::out_of_range& e) {
70858       {
70859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70860       };
70861     } catch (std::exception& e) {
70862       {
70863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70864       };
70865     } catch (Dali::DaliException e) {
70866       {
70867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70868       };
70869     } catch (...) {
70870       {
70871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70872       };
70873     }
70874   }
70875
70876   jresult = result;
70877   return jresult;
70878 }
70879
70880
70881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
70882   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70883   float arg2 ;
70884
70885   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70886   arg2 = (float)jarg2;
70887   {
70888     try {
70889       (arg1)->SetWheelScrollDistanceStep(arg2);
70890     } catch (std::out_of_range& e) {
70891       {
70892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70893       };
70894     } catch (std::exception& e) {
70895       {
70896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70897       };
70898     } catch (Dali::DaliException e) {
70899       {
70900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70901       };
70902     } catch (...) {
70903       {
70904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70905       };
70906     }
70907   }
70908
70909 }
70910
70911
70912 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
70913   float jresult ;
70914   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70915   float result;
70916
70917   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70918   {
70919     try {
70920       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
70921     } catch (std::out_of_range& e) {
70922       {
70923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70924       };
70925     } catch (std::exception& e) {
70926       {
70927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70928       };
70929     } catch (Dali::DaliException e) {
70930       {
70931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70932       };
70933     } catch (...) {
70934       {
70935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70936       };
70937     }
70938   }
70939
70940   jresult = result;
70941   return jresult;
70942 }
70943
70944
70945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
70946   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70947   bool arg2 ;
70948
70949   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70950   arg2 = jarg2 ? true : false;
70951   {
70952     try {
70953       (arg1)->SetAnchoring(arg2);
70954     } catch (std::out_of_range& e) {
70955       {
70956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70957       };
70958     } catch (std::exception& e) {
70959       {
70960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70961       };
70962     } catch (Dali::DaliException e) {
70963       {
70964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70965       };
70966     } catch (...) {
70967       {
70968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70969       };
70970     }
70971   }
70972
70973 }
70974
70975 //// ========================= end of part 3 =============================
70976
70977 //// ========================== start part 4 ===============================
70978
70979
70980 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
70981   unsigned int jresult ;
70982   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70983   bool result;
70984
70985   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70986   {
70987     try {
70988       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
70989     } catch (std::out_of_range& e) {
70990       {
70991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70992       };
70993     } catch (std::exception& e) {
70994       {
70995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70996       };
70997     } catch (Dali::DaliException e) {
70998       {
70999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71000       };
71001     } catch (...) {
71002       {
71003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71004       };
71005     }
71006   }
71007
71008   jresult = result;
71009   return jresult;
71010 }
71011
71012
71013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71014   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71015   float arg2 ;
71016
71017   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71018   arg2 = (float)jarg2;
71019   {
71020     try {
71021       (arg1)->SetAnchoringDuration(arg2);
71022     } catch (std::out_of_range& e) {
71023       {
71024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71025       };
71026     } catch (std::exception& e) {
71027       {
71028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71029       };
71030     } catch (Dali::DaliException e) {
71031       {
71032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71033       };
71034     } catch (...) {
71035       {
71036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71037       };
71038     }
71039   }
71040
71041 }
71042
71043
71044 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71045   float jresult ;
71046   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71047   float result;
71048
71049   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71050   {
71051     try {
71052       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71053     } catch (std::out_of_range& e) {
71054       {
71055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71056       };
71057     } catch (std::exception& e) {
71058       {
71059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71060       };
71061     } catch (Dali::DaliException e) {
71062       {
71063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71064       };
71065     } catch (...) {
71066       {
71067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71068       };
71069     }
71070   }
71071
71072   jresult = result;
71073   return jresult;
71074 }
71075
71076
71077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71078   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71079   Dali::Toolkit::ItemId arg2 ;
71080   float arg3 ;
71081
71082   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71083   arg2 = (Dali::Toolkit::ItemId)jarg2;
71084   arg3 = (float)jarg3;
71085   {
71086     try {
71087       (arg1)->ScrollToItem(arg2,arg3);
71088     } catch (std::out_of_range& e) {
71089       {
71090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71091       };
71092     } catch (std::exception& e) {
71093       {
71094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71095       };
71096     } catch (Dali::DaliException e) {
71097       {
71098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71099       };
71100     } catch (...) {
71101       {
71102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71103       };
71104     }
71105   }
71106
71107 }
71108
71109
71110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71111   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71112   float arg2 ;
71113
71114   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71115   arg2 = (float)jarg2;
71116   {
71117     try {
71118       (arg1)->SetRefreshInterval(arg2);
71119     } catch (std::out_of_range& e) {
71120       {
71121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71122       };
71123     } catch (std::exception& e) {
71124       {
71125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71126       };
71127     } catch (Dali::DaliException e) {
71128       {
71129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71130       };
71131     } catch (...) {
71132       {
71133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71134       };
71135     }
71136   }
71137
71138 }
71139
71140
71141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71142   float jresult ;
71143   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71144   float result;
71145
71146   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71147   {
71148     try {
71149       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71150     } catch (std::out_of_range& e) {
71151       {
71152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71153       };
71154     } catch (std::exception& e) {
71155       {
71156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71157       };
71158     } catch (Dali::DaliException e) {
71159       {
71160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71161       };
71162     } catch (...) {
71163       {
71164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71165       };
71166     }
71167   }
71168
71169   jresult = result;
71170   return jresult;
71171 }
71172
71173
71174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71175   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71176
71177   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71178   {
71179     try {
71180       (arg1)->Refresh();
71181     } catch (std::out_of_range& e) {
71182       {
71183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71184       };
71185     } catch (std::exception& e) {
71186       {
71187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71188       };
71189     } catch (Dali::DaliException e) {
71190       {
71191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71192       };
71193     } catch (...) {
71194       {
71195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71196       };
71197     }
71198   }
71199
71200 }
71201
71202
71203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71204   void * jresult ;
71205   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71206   Dali::Toolkit::ItemId arg2 ;
71207   Dali::Actor result;
71208
71209   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71210   arg2 = (Dali::Toolkit::ItemId)jarg2;
71211   {
71212     try {
71213       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71214     } catch (std::out_of_range& e) {
71215       {
71216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71217       };
71218     } catch (std::exception& e) {
71219       {
71220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71221       };
71222     } catch (Dali::DaliException e) {
71223       {
71224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71225       };
71226     } catch (...) {
71227       {
71228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71229       };
71230     }
71231   }
71232
71233   jresult = new Dali::Actor((const Dali::Actor &)result);
71234   return jresult;
71235 }
71236
71237
71238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71239   unsigned int jresult ;
71240   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71241   Dali::Actor arg2 ;
71242   Dali::Actor *argp2 ;
71243   Dali::Toolkit::ItemId result;
71244
71245   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71246   argp2 = (Dali::Actor *)jarg2;
71247   if (!argp2) {
71248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71249     return 0;
71250   }
71251   arg2 = *argp2;
71252   {
71253     try {
71254       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71255     } catch (std::out_of_range& e) {
71256       {
71257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71258       };
71259     } catch (std::exception& e) {
71260       {
71261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71262       };
71263     } catch (Dali::DaliException e) {
71264       {
71265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71266       };
71267     } catch (...) {
71268       {
71269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71270       };
71271     }
71272   }
71273
71274   jresult = result;
71275   return jresult;
71276 }
71277
71278
71279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71280   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71281   Dali::Toolkit::Item arg2 ;
71282   float arg3 ;
71283   Dali::Toolkit::Item *argp2 ;
71284
71285   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71286   argp2 = (Dali::Toolkit::Item *)jarg2;
71287   if (!argp2) {
71288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71289     return ;
71290   }
71291   arg2 = *argp2;
71292   arg3 = (float)jarg3;
71293   {
71294     try {
71295       (arg1)->InsertItem(arg2,arg3);
71296     } catch (std::out_of_range& e) {
71297       {
71298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71299       };
71300     } catch (std::exception& e) {
71301       {
71302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71303       };
71304     } catch (Dali::DaliException e) {
71305       {
71306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71307       };
71308     } catch (...) {
71309       {
71310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71311       };
71312     }
71313   }
71314
71315 }
71316
71317
71318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71319   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71320   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71321   float arg3 ;
71322
71323   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71324   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71325   if (!arg2) {
71326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71327     return ;
71328   }
71329   arg3 = (float)jarg3;
71330   {
71331     try {
71332       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71333     } catch (std::out_of_range& e) {
71334       {
71335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71336       };
71337     } catch (std::exception& e) {
71338       {
71339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71340       };
71341     } catch (Dali::DaliException e) {
71342       {
71343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71344       };
71345     } catch (...) {
71346       {
71347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71348       };
71349     }
71350   }
71351
71352 }
71353
71354
71355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71356   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71357   Dali::Toolkit::ItemId arg2 ;
71358   float arg3 ;
71359
71360   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71361   arg2 = (Dali::Toolkit::ItemId)jarg2;
71362   arg3 = (float)jarg3;
71363   {
71364     try {
71365       (arg1)->RemoveItem(arg2,arg3);
71366     } catch (std::out_of_range& e) {
71367       {
71368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71369       };
71370     } catch (std::exception& e) {
71371       {
71372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71373       };
71374     } catch (Dali::DaliException e) {
71375       {
71376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71377       };
71378     } catch (...) {
71379       {
71380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71381       };
71382     }
71383   }
71384
71385 }
71386
71387
71388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71389   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71390   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71391   float arg3 ;
71392
71393   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71394   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71395   if (!arg2) {
71396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71397     return ;
71398   }
71399   arg3 = (float)jarg3;
71400   {
71401     try {
71402       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71403     } catch (std::out_of_range& e) {
71404       {
71405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71406       };
71407     } catch (std::exception& e) {
71408       {
71409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71410       };
71411     } catch (Dali::DaliException e) {
71412       {
71413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71414       };
71415     } catch (...) {
71416       {
71417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71418       };
71419     }
71420   }
71421
71422 }
71423
71424
71425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71426   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71427   Dali::Toolkit::Item arg2 ;
71428   float arg3 ;
71429   Dali::Toolkit::Item *argp2 ;
71430
71431   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71432   argp2 = (Dali::Toolkit::Item *)jarg2;
71433   if (!argp2) {
71434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71435     return ;
71436   }
71437   arg2 = *argp2;
71438   arg3 = (float)jarg3;
71439   {
71440     try {
71441       (arg1)->ReplaceItem(arg2,arg3);
71442     } catch (std::out_of_range& e) {
71443       {
71444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71445       };
71446     } catch (std::exception& e) {
71447       {
71448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71449       };
71450     } catch (Dali::DaliException e) {
71451       {
71452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71453       };
71454     } catch (...) {
71455       {
71456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71457       };
71458     }
71459   }
71460
71461 }
71462
71463
71464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71465   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71466   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71467   float arg3 ;
71468
71469   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71470   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71471   if (!arg2) {
71472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71473     return ;
71474   }
71475   arg3 = (float)jarg3;
71476   {
71477     try {
71478       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71479     } catch (std::out_of_range& e) {
71480       {
71481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71482       };
71483     } catch (std::exception& e) {
71484       {
71485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71486       };
71487     } catch (Dali::DaliException e) {
71488       {
71489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71490       };
71491     } catch (...) {
71492       {
71493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71494       };
71495     }
71496   }
71497
71498 }
71499
71500
71501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71502   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71503   Dali::Vector3 *arg2 = 0 ;
71504
71505   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71506   arg2 = (Dali::Vector3 *)jarg2;
71507   if (!arg2) {
71508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71509     return ;
71510   }
71511   {
71512     try {
71513       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71514     } catch (std::out_of_range& e) {
71515       {
71516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71517       };
71518     } catch (std::exception& e) {
71519       {
71520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71521       };
71522     } catch (Dali::DaliException e) {
71523       {
71524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71525       };
71526     } catch (...) {
71527       {
71528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71529       };
71530     }
71531   }
71532
71533 }
71534
71535
71536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
71537   void * jresult ;
71538   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71539   Dali::Vector3 result;
71540
71541   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71542   {
71543     try {
71544       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71545     } catch (std::out_of_range& e) {
71546       {
71547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71548       };
71549     } catch (std::exception& e) {
71550       {
71551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71552       };
71553     } catch (Dali::DaliException e) {
71554       {
71555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71556       };
71557     } catch (...) {
71558       {
71559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71560       };
71561     }
71562   }
71563
71564   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71565   return jresult;
71566 }
71567
71568
71569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71570   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71571   Dali::Vector3 *arg2 = 0 ;
71572
71573   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71574   arg2 = (Dali::Vector3 *)jarg2;
71575   if (!arg2) {
71576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71577     return ;
71578   }
71579   {
71580     try {
71581       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71582     } catch (std::out_of_range& e) {
71583       {
71584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71585       };
71586     } catch (std::exception& e) {
71587       {
71588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71589       };
71590     } catch (Dali::DaliException e) {
71591       {
71592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71593       };
71594     } catch (...) {
71595       {
71596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71597       };
71598     }
71599   }
71600
71601 }
71602
71603
71604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
71605   void * jresult ;
71606   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71607   Dali::Vector3 result;
71608
71609   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71610   {
71611     try {
71612       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
71613     } catch (std::out_of_range& e) {
71614       {
71615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71616       };
71617     } catch (std::exception& e) {
71618       {
71619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71620       };
71621     } catch (Dali::DaliException e) {
71622       {
71623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71624       };
71625     } catch (...) {
71626       {
71627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71628       };
71629     }
71630   }
71631
71632   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71633   return jresult;
71634 }
71635
71636
71637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
71638   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71639   Dali::Toolkit::ItemRange *arg2 = 0 ;
71640
71641   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71642   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
71643   if (!arg2) {
71644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
71645     return ;
71646   }
71647   {
71648     try {
71649       (arg1)->GetItemsRange(*arg2);
71650     } catch (std::out_of_range& e) {
71651       {
71652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71653       };
71654     } catch (std::exception& e) {
71655       {
71656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71657       };
71658     } catch (Dali::DaliException e) {
71659       {
71660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71661       };
71662     } catch (...) {
71663       {
71664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71665       };
71666     }
71667   }
71668
71669 }
71670
71671
71672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
71673   void * jresult ;
71674   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71675   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
71676
71677   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71678   {
71679     try {
71680       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
71681     } catch (std::out_of_range& e) {
71682       {
71683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71684       };
71685     } catch (std::exception& e) {
71686       {
71687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71688       };
71689     } catch (Dali::DaliException e) {
71690       {
71691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71692       };
71693     } catch (...) {
71694       {
71695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71696       };
71697     }
71698   }
71699
71700   jresult = (void *)result;
71701   return jresult;
71702 }
71703
71704
71705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
71706   Dali::Vector3 *arg1 = 0 ;
71707   PropertyInputContainer *arg2 = 0 ;
71708
71709   arg1 = (Dali::Vector3 *)jarg1;
71710   if (!arg1) {
71711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71712     return ;
71713   }
71714   arg2 = (PropertyInputContainer *)jarg2;
71715   if (!arg2) {
71716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71717     return ;
71718   }
71719   {
71720     try {
71721       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71722     } catch (std::out_of_range& e) {
71723       {
71724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71725       };
71726     } catch (std::exception& e) {
71727       {
71728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71729       };
71730     } catch (Dali::DaliException e) {
71731       {
71732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71733       };
71734     } catch (...) {
71735       {
71736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71737       };
71738     }
71739   }
71740
71741 }
71742
71743
71744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
71745   Dali::Vector3 *arg1 = 0 ;
71746   PropertyInputContainer *arg2 = 0 ;
71747
71748   arg1 = (Dali::Vector3 *)jarg1;
71749   if (!arg1) {
71750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71751     return ;
71752   }
71753   arg2 = (PropertyInputContainer *)jarg2;
71754   if (!arg2) {
71755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71756     return ;
71757   }
71758   {
71759     try {
71760       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71761     } catch (std::out_of_range& e) {
71762       {
71763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71764       };
71765     } catch (std::exception& e) {
71766       {
71767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71768       };
71769     } catch (Dali::DaliException e) {
71770       {
71771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71772       };
71773     } catch (...) {
71774       {
71775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71776       };
71777     }
71778   }
71779
71780 }
71781
71782
71783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
71784   void * jresult ;
71785   Dali::Toolkit::ScrollViewEffect *result = 0 ;
71786
71787   {
71788     try {
71789       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
71790     } catch (std::out_of_range& e) {
71791       {
71792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71793       };
71794     } catch (std::exception& e) {
71795       {
71796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71797       };
71798     } catch (Dali::DaliException e) {
71799       {
71800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71801       };
71802     } catch (...) {
71803       {
71804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71805       };
71806     }
71807   }
71808
71809   jresult = (void *)result;
71810   return jresult;
71811 }
71812
71813
71814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
71815   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
71816
71817   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
71818   {
71819     try {
71820       delete arg1;
71821     } catch (std::out_of_range& e) {
71822       {
71823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71824       };
71825     } catch (std::exception& e) {
71826       {
71827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71828       };
71829     } catch (Dali::DaliException e) {
71830       {
71831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71832       };
71833     } catch (...) {
71834       {
71835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71836       };
71837     }
71838   }
71839
71840 }
71841
71842
71843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
71844   void * jresult ;
71845   Dali::Path arg1 ;
71846   Dali::Vector3 *arg2 = 0 ;
71847   Dali::Property::Index arg3 ;
71848   Dali::Vector3 *arg4 = 0 ;
71849   unsigned int arg5 ;
71850   Dali::Path *argp1 ;
71851   Dali::Toolkit::ScrollViewPagePathEffect result;
71852
71853   argp1 = (Dali::Path *)jarg1;
71854   if (!argp1) {
71855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
71856     return 0;
71857   }
71858   arg1 = *argp1;
71859   arg2 = (Dali::Vector3 *)jarg2;
71860   if (!arg2) {
71861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71862     return 0;
71863   }
71864   arg3 = (Dali::Property::Index)jarg3;
71865   arg4 = (Dali::Vector3 *)jarg4;
71866   if (!arg4) {
71867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71868     return 0;
71869   }
71870   arg5 = (unsigned int)jarg5;
71871   {
71872     try {
71873       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
71874     } catch (std::out_of_range& e) {
71875       {
71876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71877       };
71878     } catch (std::exception& e) {
71879       {
71880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71881       };
71882     } catch (Dali::DaliException e) {
71883       {
71884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71885       };
71886     } catch (...) {
71887       {
71888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71889       };
71890     }
71891   }
71892
71893   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71894   return jresult;
71895 }
71896
71897
71898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
71899   void * jresult ;
71900   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
71901
71902   {
71903     try {
71904       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
71905     } catch (std::out_of_range& e) {
71906       {
71907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71908       };
71909     } catch (std::exception& e) {
71910       {
71911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71912       };
71913     } catch (Dali::DaliException e) {
71914       {
71915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71916       };
71917     } catch (...) {
71918       {
71919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71920       };
71921     }
71922   }
71923
71924   jresult = (void *)result;
71925   return jresult;
71926 }
71927
71928
71929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
71930   void * jresult ;
71931   Dali::BaseHandle arg1 ;
71932   Dali::BaseHandle *argp1 ;
71933   Dali::Toolkit::ScrollViewPagePathEffect result;
71934
71935   argp1 = (Dali::BaseHandle *)jarg1;
71936   if (!argp1) {
71937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71938     return 0;
71939   }
71940   arg1 = *argp1;
71941   {
71942     try {
71943       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
71944     } catch (std::out_of_range& e) {
71945       {
71946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71947       };
71948     } catch (std::exception& e) {
71949       {
71950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71951       };
71952     } catch (Dali::DaliException e) {
71953       {
71954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71955       };
71956     } catch (...) {
71957       {
71958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71959       };
71960     }
71961   }
71962
71963   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
71964   return jresult;
71965 }
71966
71967
71968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
71969   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
71970   Dali::Actor arg2 ;
71971   unsigned int arg3 ;
71972   Dali::Actor *argp2 ;
71973
71974   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
71975   argp2 = (Dali::Actor *)jarg2;
71976   if (!argp2) {
71977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71978     return ;
71979   }
71980   arg2 = *argp2;
71981   arg3 = (unsigned int)jarg3;
71982   {
71983     try {
71984       (arg1)->ApplyToPage(arg2,arg3);
71985     } catch (std::out_of_range& e) {
71986       {
71987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71988       };
71989     } catch (std::exception& e) {
71990       {
71991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71992       };
71993     } catch (Dali::DaliException e) {
71994       {
71995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71996       };
71997     } catch (...) {
71998       {
71999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72000       };
72001     }
72002   }
72003
72004 }
72005
72006
72007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72008   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72009
72010   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72011   {
72012     try {
72013       delete arg1;
72014     } catch (std::out_of_range& e) {
72015       {
72016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72017       };
72018     } catch (std::exception& e) {
72019       {
72020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72021       };
72022     } catch (Dali::DaliException e) {
72023       {
72024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72025       };
72026     } catch (...) {
72027       {
72028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72029       };
72030     }
72031   }
72032
72033 }
72034
72035
72036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
72037   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72038   Dali::Toolkit::ClampState arg2 ;
72039
72040   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72041   arg2 = (Dali::Toolkit::ClampState)jarg2;
72042   if (arg1) (arg1)->x = arg2;
72043 }
72044
72045
72046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
72047   int jresult ;
72048   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72049   Dali::Toolkit::ClampState result;
72050
72051   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72052   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72053   jresult = (int)result;
72054   return jresult;
72055 }
72056
72057
72058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72059   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72060   Dali::Toolkit::ClampState arg2 ;
72061
72062   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72063   arg2 = (Dali::Toolkit::ClampState)jarg2;
72064   if (arg1) (arg1)->y = arg2;
72065 }
72066
72067
72068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72069   int jresult ;
72070   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72071   Dali::Toolkit::ClampState result;
72072
72073   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72074   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72075   jresult = (int)result;
72076   return jresult;
72077 }
72078
72079
72080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72081   void * jresult ;
72082   Dali::Toolkit::ClampState2D *result = 0 ;
72083
72084   {
72085     try {
72086       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72087     } catch (std::out_of_range& e) {
72088       {
72089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72090       };
72091     } catch (std::exception& e) {
72092       {
72093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72094       };
72095     } catch (Dali::DaliException e) {
72096       {
72097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72098       };
72099     } catch (...) {
72100       {
72101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72102       };
72103     }
72104   }
72105
72106   jresult = (void *)result;
72107   return jresult;
72108 }
72109
72110
72111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72112   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72113
72114   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72115   {
72116     try {
72117       delete arg1;
72118     } catch (std::out_of_range& e) {
72119       {
72120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72121       };
72122     } catch (std::exception& e) {
72123       {
72124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72125       };
72126     } catch (Dali::DaliException e) {
72127       {
72128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72129       };
72130     } catch (...) {
72131       {
72132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72133       };
72134     }
72135   }
72136
72137 }
72138
72139
72140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72141   void * jresult ;
72142   float arg1 ;
72143   float arg2 ;
72144   bool arg3 ;
72145   Dali::Toolkit::RulerDomain *result = 0 ;
72146
72147   arg1 = (float)jarg1;
72148   arg2 = (float)jarg2;
72149   arg3 = jarg3 ? true : false;
72150   {
72151     try {
72152       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72153     } catch (std::out_of_range& e) {
72154       {
72155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72156       };
72157     } catch (std::exception& e) {
72158       {
72159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72160       };
72161     } catch (Dali::DaliException e) {
72162       {
72163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72164       };
72165     } catch (...) {
72166       {
72167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72168       };
72169     }
72170   }
72171
72172   jresult = (void *)result;
72173   return jresult;
72174 }
72175
72176
72177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72178   void * jresult ;
72179   float arg1 ;
72180   float arg2 ;
72181   Dali::Toolkit::RulerDomain *result = 0 ;
72182
72183   arg1 = (float)jarg1;
72184   arg2 = (float)jarg2;
72185   {
72186     try {
72187       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72188     } catch (std::out_of_range& e) {
72189       {
72190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72191       };
72192     } catch (std::exception& e) {
72193       {
72194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72195       };
72196     } catch (Dali::DaliException e) {
72197       {
72198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72199       };
72200     } catch (...) {
72201       {
72202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72203       };
72204     }
72205   }
72206
72207   jresult = (void *)result;
72208   return jresult;
72209 }
72210
72211
72212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
72213   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72214   float arg2 ;
72215
72216   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72217   arg2 = (float)jarg2;
72218   if (arg1) (arg1)->min = arg2;
72219 }
72220
72221
72222 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
72223   float jresult ;
72224   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72225   float result;
72226
72227   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72228   result = (float) ((arg1)->min);
72229   jresult = result;
72230   return jresult;
72231 }
72232
72233
72234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72235   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72236   float arg2 ;
72237
72238   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72239   arg2 = (float)jarg2;
72240   if (arg1) (arg1)->max = arg2;
72241 }
72242
72243
72244 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72245   float jresult ;
72246   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72247   float result;
72248
72249   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72250   result = (float) ((arg1)->max);
72251   jresult = result;
72252   return jresult;
72253 }
72254
72255
72256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72257   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72258   bool arg2 ;
72259
72260   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72261   arg2 = jarg2 ? true : false;
72262   if (arg1) (arg1)->enabled = arg2;
72263 }
72264
72265
72266 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72267   unsigned int jresult ;
72268   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72269   bool result;
72270
72271   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72272   result = (bool) ((arg1)->enabled);
72273   jresult = result;
72274   return jresult;
72275 }
72276
72277
72278 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72279   float jresult ;
72280   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72281   float arg2 ;
72282   float arg3 ;
72283   float arg4 ;
72284   float result;
72285
72286   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72287   arg2 = (float)jarg2;
72288   arg3 = (float)jarg3;
72289   arg4 = (float)jarg4;
72290   {
72291     try {
72292       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72293     } catch (std::out_of_range& e) {
72294       {
72295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72296       };
72297     } catch (std::exception& e) {
72298       {
72299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72300       };
72301     } catch (Dali::DaliException e) {
72302       {
72303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72304       };
72305     } catch (...) {
72306       {
72307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72308       };
72309     }
72310   }
72311
72312   jresult = result;
72313   return jresult;
72314 }
72315
72316
72317 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72318   float jresult ;
72319   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72320   float arg2 ;
72321   float arg3 ;
72322   float result;
72323
72324   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72325   arg2 = (float)jarg2;
72326   arg3 = (float)jarg3;
72327   {
72328     try {
72329       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72330     } catch (std::out_of_range& e) {
72331       {
72332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72333       };
72334     } catch (std::exception& e) {
72335       {
72336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72337       };
72338     } catch (Dali::DaliException e) {
72339       {
72340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72341       };
72342     } catch (...) {
72343       {
72344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72345       };
72346     }
72347   }
72348
72349   jresult = result;
72350   return jresult;
72351 }
72352
72353
72354 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72355   float jresult ;
72356   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72357   float arg2 ;
72358   float result;
72359
72360   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72361   arg2 = (float)jarg2;
72362   {
72363     try {
72364       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72365     } catch (std::out_of_range& e) {
72366       {
72367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72368       };
72369     } catch (std::exception& e) {
72370       {
72371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72372       };
72373     } catch (Dali::DaliException e) {
72374       {
72375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72376       };
72377     } catch (...) {
72378       {
72379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72380       };
72381     }
72382   }
72383
72384   jresult = result;
72385   return jresult;
72386 }
72387
72388
72389 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72390   float jresult ;
72391   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72392   float arg2 ;
72393   float arg3 ;
72394   float arg4 ;
72395   Dali::Toolkit::ClampState *arg5 = 0 ;
72396   float result;
72397
72398   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72399   arg2 = (float)jarg2;
72400   arg3 = (float)jarg3;
72401   arg4 = (float)jarg4;
72402   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72403   if (!arg5) {
72404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72405     return 0;
72406   }
72407   {
72408     try {
72409       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72410     } catch (std::out_of_range& e) {
72411       {
72412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72413       };
72414     } catch (std::exception& e) {
72415       {
72416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72417       };
72418     } catch (Dali::DaliException e) {
72419       {
72420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72421       };
72422     } catch (...) {
72423       {
72424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72425       };
72426     }
72427   }
72428
72429   jresult = result;
72430   return jresult;
72431 }
72432
72433
72434 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
72435   float jresult ;
72436   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72437   float result;
72438
72439   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72440   {
72441     try {
72442       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72443     } catch (std::out_of_range& e) {
72444       {
72445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72446       };
72447     } catch (std::exception& e) {
72448       {
72449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72450       };
72451     } catch (Dali::DaliException e) {
72452       {
72453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72454       };
72455     } catch (...) {
72456       {
72457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72458       };
72459     }
72460   }
72461
72462   jresult = result;
72463   return jresult;
72464 }
72465
72466
72467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72468   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72469
72470   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72471   {
72472     try {
72473       delete arg1;
72474     } catch (std::out_of_range& e) {
72475       {
72476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72477       };
72478     } catch (std::exception& e) {
72479       {
72480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72481       };
72482     } catch (Dali::DaliException e) {
72483       {
72484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72485       };
72486     } catch (...) {
72487       {
72488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72489       };
72490     }
72491   }
72492
72493 }
72494
72495
72496 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72497   float jresult ;
72498   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72499   float arg2 ;
72500   float arg3 ;
72501   float result;
72502
72503   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72504   arg2 = (float)jarg2;
72505   arg3 = (float)jarg3;
72506   {
72507     try {
72508       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72509     } catch (std::out_of_range& e) {
72510       {
72511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72512       };
72513     } catch (std::exception& e) {
72514       {
72515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72516       };
72517     } catch (Dali::DaliException e) {
72518       {
72519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72520       };
72521     } catch (...) {
72522       {
72523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72524       };
72525     }
72526   }
72527
72528   jresult = result;
72529   return jresult;
72530 }
72531
72532
72533 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72534   float jresult ;
72535   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72536   float arg2 ;
72537   float result;
72538
72539   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72540   arg2 = (float)jarg2;
72541   {
72542     try {
72543       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72544     } catch (std::out_of_range& e) {
72545       {
72546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72547       };
72548     } catch (std::exception& e) {
72549       {
72550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72551       };
72552     } catch (Dali::DaliException e) {
72553       {
72554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72555       };
72556     } catch (...) {
72557       {
72558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72559       };
72560     }
72561   }
72562
72563   jresult = result;
72564   return jresult;
72565 }
72566
72567
72568 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72569   float jresult ;
72570   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72571   unsigned int arg2 ;
72572   unsigned int *arg3 = 0 ;
72573   bool arg4 ;
72574   float result;
72575
72576   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72577   arg2 = (unsigned int)jarg2;
72578   arg3 = (unsigned int *)jarg3;
72579   arg4 = jarg4 ? true : false;
72580   {
72581     try {
72582       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72583     } catch (std::out_of_range& e) {
72584       {
72585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72586       };
72587     } catch (std::exception& e) {
72588       {
72589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72590       };
72591     } catch (Dali::DaliException e) {
72592       {
72593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72594       };
72595     } catch (...) {
72596       {
72597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72598       };
72599     }
72600   }
72601
72602   jresult = result;
72603   return jresult;
72604 }
72605
72606
72607 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72608   unsigned int jresult ;
72609   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72610   float arg2 ;
72611   bool arg3 ;
72612   unsigned int result;
72613
72614   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72615   arg2 = (float)jarg2;
72616   arg3 = jarg3 ? true : false;
72617   {
72618     try {
72619       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72620     } catch (std::out_of_range& e) {
72621       {
72622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72623       };
72624     } catch (std::exception& e) {
72625       {
72626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72627       };
72628     } catch (Dali::DaliException e) {
72629       {
72630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72631       };
72632     } catch (...) {
72633       {
72634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72635       };
72636     }
72637   }
72638
72639   jresult = result;
72640   return jresult;
72641 }
72642
72643
72644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
72645   unsigned int jresult ;
72646   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72647   unsigned int result;
72648
72649   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72650   {
72651     try {
72652       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
72653     } catch (std::out_of_range& e) {
72654       {
72655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72656       };
72657     } catch (std::exception& e) {
72658       {
72659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72660       };
72661     } catch (Dali::DaliException e) {
72662       {
72663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72664       };
72665     } catch (...) {
72666       {
72667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72668       };
72669     }
72670   }
72671
72672   jresult = result;
72673   return jresult;
72674 }
72675
72676
72677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
72678   int jresult ;
72679   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72680   Dali::Toolkit::Ruler::RulerType result;
72681
72682   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72683   {
72684     try {
72685       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
72686     } catch (std::out_of_range& e) {
72687       {
72688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72689       };
72690     } catch (std::exception& e) {
72691       {
72692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72693       };
72694     } catch (Dali::DaliException e) {
72695       {
72696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72697       };
72698     } catch (...) {
72699       {
72700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72701       };
72702     }
72703   }
72704
72705   jresult = (int)result;
72706   return jresult;
72707 }
72708
72709
72710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
72711   unsigned int jresult ;
72712   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72713   bool result;
72714
72715   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72716   {
72717     try {
72718       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
72719     } catch (std::out_of_range& e) {
72720       {
72721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72722       };
72723     } catch (std::exception& e) {
72724       {
72725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72726       };
72727     } catch (Dali::DaliException e) {
72728       {
72729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72730       };
72731     } catch (...) {
72732       {
72733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72734       };
72735     }
72736   }
72737
72738   jresult = result;
72739   return jresult;
72740 }
72741
72742
72743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
72744   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72745
72746   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72747   {
72748     try {
72749       (arg1)->Enable();
72750     } catch (std::out_of_range& e) {
72751       {
72752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72753       };
72754     } catch (std::exception& e) {
72755       {
72756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72757       };
72758     } catch (Dali::DaliException e) {
72759       {
72760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72761       };
72762     } catch (...) {
72763       {
72764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72765       };
72766     }
72767   }
72768
72769 }
72770
72771
72772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
72773   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72774
72775   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72776   {
72777     try {
72778       (arg1)->Disable();
72779     } catch (std::out_of_range& e) {
72780       {
72781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72782       };
72783     } catch (std::exception& e) {
72784       {
72785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72786       };
72787     } catch (Dali::DaliException e) {
72788       {
72789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72790       };
72791     } catch (...) {
72792       {
72793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72794       };
72795     }
72796   }
72797
72798 }
72799
72800
72801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
72802   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72803   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
72804   Dali::Toolkit::RulerDomain *argp2 ;
72805
72806   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72807   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
72808   if (!argp2) {
72809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
72810     return ;
72811   }
72812   arg2 = *argp2;
72813   {
72814     try {
72815       (arg1)->SetDomain(arg2);
72816     } catch (std::out_of_range& e) {
72817       {
72818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72819       };
72820     } catch (std::exception& e) {
72821       {
72822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72823       };
72824     } catch (Dali::DaliException e) {
72825       {
72826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72827       };
72828     } catch (...) {
72829       {
72830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72831       };
72832     }
72833   }
72834
72835 }
72836
72837
72838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
72839   void * jresult ;
72840   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72841   Dali::Toolkit::RulerDomain *result = 0 ;
72842
72843   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72844   {
72845     try {
72846       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
72847     } catch (std::out_of_range& e) {
72848       {
72849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72850       };
72851     } catch (std::exception& e) {
72852       {
72853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72854       };
72855     } catch (Dali::DaliException e) {
72856       {
72857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72858       };
72859     } catch (...) {
72860       {
72861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72862       };
72863     }
72864   }
72865
72866   jresult = (void *)result;
72867   return jresult;
72868 }
72869
72870
72871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
72872   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72873
72874   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72875   {
72876     try {
72877       (arg1)->DisableDomain();
72878     } catch (std::out_of_range& e) {
72879       {
72880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72881       };
72882     } catch (std::exception& e) {
72883       {
72884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72885       };
72886     } catch (Dali::DaliException e) {
72887       {
72888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72889       };
72890     } catch (...) {
72891       {
72892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72893       };
72894     }
72895   }
72896
72897 }
72898
72899
72900 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72901   float jresult ;
72902   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72903   float arg2 ;
72904   float arg3 ;
72905   float arg4 ;
72906   float result;
72907
72908   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72909   arg2 = (float)jarg2;
72910   arg3 = (float)jarg3;
72911   arg4 = (float)jarg4;
72912   {
72913     try {
72914       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
72915     } catch (std::out_of_range& e) {
72916       {
72917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72918       };
72919     } catch (std::exception& e) {
72920       {
72921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72922       };
72923     } catch (Dali::DaliException e) {
72924       {
72925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72926       };
72927     } catch (...) {
72928       {
72929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72930       };
72931     }
72932   }
72933
72934   jresult = result;
72935   return jresult;
72936 }
72937
72938
72939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72940   float jresult ;
72941   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72942   float arg2 ;
72943   float arg3 ;
72944   float result;
72945
72946   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72947   arg2 = (float)jarg2;
72948   arg3 = (float)jarg3;
72949   {
72950     try {
72951       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
72952     } catch (std::out_of_range& e) {
72953       {
72954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72955       };
72956     } catch (std::exception& e) {
72957       {
72958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72959       };
72960     } catch (Dali::DaliException e) {
72961       {
72962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72963       };
72964     } catch (...) {
72965       {
72966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72967       };
72968     }
72969   }
72970
72971   jresult = result;
72972   return jresult;
72973 }
72974
72975
72976 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
72977   float jresult ;
72978   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72979   float arg2 ;
72980   float result;
72981
72982   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72983   arg2 = (float)jarg2;
72984   {
72985     try {
72986       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
72987     } catch (std::out_of_range& e) {
72988       {
72989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72990       };
72991     } catch (std::exception& e) {
72992       {
72993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72994       };
72995     } catch (Dali::DaliException e) {
72996       {
72997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72998       };
72999     } catch (...) {
73000       {
73001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73002       };
73003     }
73004   }
73005
73006   jresult = result;
73007   return jresult;
73008 }
73009
73010
73011 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73012   float jresult ;
73013   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73014   float arg2 ;
73015   float arg3 ;
73016   float arg4 ;
73017   Dali::Toolkit::ClampState *arg5 = 0 ;
73018   float result;
73019
73020   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73021   arg2 = (float)jarg2;
73022   arg3 = (float)jarg3;
73023   arg4 = (float)jarg4;
73024   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73025   if (!arg5) {
73026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73027     return 0;
73028   }
73029   {
73030     try {
73031       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73032     } catch (std::out_of_range& e) {
73033       {
73034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73035       };
73036     } catch (std::exception& e) {
73037       {
73038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73039       };
73040     } catch (Dali::DaliException e) {
73041       {
73042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73043       };
73044     } catch (...) {
73045       {
73046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73047       };
73048     }
73049   }
73050
73051   jresult = result;
73052   return jresult;
73053 }
73054
73055
73056 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73057   float jresult ;
73058   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73059   float arg2 ;
73060   float arg3 ;
73061   float arg4 ;
73062   float arg5 ;
73063   float result;
73064
73065   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73066   arg2 = (float)jarg2;
73067   arg3 = (float)jarg3;
73068   arg4 = (float)jarg4;
73069   arg5 = (float)jarg5;
73070   {
73071     try {
73072       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73073     } catch (std::out_of_range& e) {
73074       {
73075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73076       };
73077     } catch (std::exception& e) {
73078       {
73079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73080       };
73081     } catch (Dali::DaliException e) {
73082       {
73083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73084       };
73085     } catch (...) {
73086       {
73087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73088       };
73089     }
73090   }
73091
73092   jresult = result;
73093   return jresult;
73094 }
73095
73096
73097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73098   float jresult ;
73099   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73100   float arg2 ;
73101   float arg3 ;
73102   float arg4 ;
73103   float result;
73104
73105   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73106   arg2 = (float)jarg2;
73107   arg3 = (float)jarg3;
73108   arg4 = (float)jarg4;
73109   {
73110     try {
73111       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
73112     } catch (std::out_of_range& e) {
73113       {
73114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73115       };
73116     } catch (std::exception& e) {
73117       {
73118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73119       };
73120     } catch (Dali::DaliException e) {
73121       {
73122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73123       };
73124     } catch (...) {
73125       {
73126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73127       };
73128     }
73129   }
73130
73131   jresult = result;
73132   return jresult;
73133 }
73134
73135
73136 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73137   float jresult ;
73138   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73139   float arg2 ;
73140   float arg3 ;
73141   float result;
73142
73143   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73144   arg2 = (float)jarg2;
73145   arg3 = (float)jarg3;
73146   {
73147     try {
73148       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
73149     } catch (std::out_of_range& e) {
73150       {
73151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73152       };
73153     } catch (std::exception& e) {
73154       {
73155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73156       };
73157     } catch (Dali::DaliException e) {
73158       {
73159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73160       };
73161     } catch (...) {
73162       {
73163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73164       };
73165     }
73166   }
73167
73168   jresult = result;
73169   return jresult;
73170 }
73171
73172
73173 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73174   float jresult ;
73175   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73176   float arg2 ;
73177   float result;
73178
73179   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73180   arg2 = (float)jarg2;
73181   {
73182     try {
73183       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73184     } catch (std::out_of_range& e) {
73185       {
73186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73187       };
73188     } catch (std::exception& e) {
73189       {
73190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73191       };
73192     } catch (Dali::DaliException e) {
73193       {
73194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73195       };
73196     } catch (...) {
73197       {
73198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73199       };
73200     }
73201   }
73202
73203   jresult = result;
73204   return jresult;
73205 }
73206
73207
73208 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73209   float jresult ;
73210   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73211   float arg2 ;
73212   float arg3 ;
73213   float arg4 ;
73214   float arg5 ;
73215   Dali::Toolkit::ClampState *arg6 = 0 ;
73216   float result;
73217
73218   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73219   arg2 = (float)jarg2;
73220   arg3 = (float)jarg3;
73221   arg4 = (float)jarg4;
73222   arg5 = (float)jarg5;
73223   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73224   if (!arg6) {
73225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73226     return 0;
73227   }
73228   {
73229     try {
73230       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73231     } catch (std::out_of_range& e) {
73232       {
73233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73234       };
73235     } catch (std::exception& e) {
73236       {
73237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73238       };
73239     } catch (Dali::DaliException e) {
73240       {
73241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73242       };
73243     } catch (...) {
73244       {
73245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73246       };
73247     }
73248   }
73249
73250   jresult = result;
73251   return jresult;
73252 }
73253
73254
73255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73256   void * jresult ;
73257   Dali::Toolkit::DefaultRuler *result = 0 ;
73258
73259   {
73260     try {
73261       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73262     } catch (std::out_of_range& e) {
73263       {
73264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73265       };
73266     } catch (std::exception& e) {
73267       {
73268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73269       };
73270     } catch (Dali::DaliException e) {
73271       {
73272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73273       };
73274     } catch (...) {
73275       {
73276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73277       };
73278     }
73279   }
73280
73281   jresult = (void *)result;
73282   return jresult;
73283 }
73284
73285
73286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73287   float jresult ;
73288   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73289   float arg2 ;
73290   float arg3 ;
73291   float result;
73292
73293   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73294   arg2 = (float)jarg2;
73295   arg3 = (float)jarg3;
73296   {
73297     try {
73298       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73299     } catch (std::out_of_range& e) {
73300       {
73301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73302       };
73303     } catch (std::exception& e) {
73304       {
73305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73306       };
73307     } catch (Dali::DaliException e) {
73308       {
73309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73310       };
73311     } catch (...) {
73312       {
73313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73314       };
73315     }
73316   }
73317
73318   jresult = result;
73319   return jresult;
73320 }
73321
73322
73323 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73324   float jresult ;
73325   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73326   unsigned int arg2 ;
73327   unsigned int *arg3 = 0 ;
73328   bool arg4 ;
73329   float result;
73330
73331   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73332   arg2 = (unsigned int)jarg2;
73333   arg3 = (unsigned int *)jarg3;
73334   arg4 = jarg4 ? true : false;
73335   {
73336     try {
73337       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73338     } catch (std::out_of_range& e) {
73339       {
73340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73341       };
73342     } catch (std::exception& e) {
73343       {
73344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73345       };
73346     } catch (Dali::DaliException e) {
73347       {
73348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73349       };
73350     } catch (...) {
73351       {
73352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73353       };
73354     }
73355   }
73356
73357   jresult = result;
73358   return jresult;
73359 }
73360
73361
73362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73363   unsigned int jresult ;
73364   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73365   float arg2 ;
73366   bool arg3 ;
73367   unsigned int result;
73368
73369   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73370   arg2 = (float)jarg2;
73371   arg3 = jarg3 ? true : false;
73372   {
73373     try {
73374       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73375     } catch (std::out_of_range& e) {
73376       {
73377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73378       };
73379     } catch (std::exception& e) {
73380       {
73381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73382       };
73383     } catch (Dali::DaliException e) {
73384       {
73385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73386       };
73387     } catch (...) {
73388       {
73389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73390       };
73391     }
73392   }
73393
73394   jresult = result;
73395   return jresult;
73396 }
73397
73398
73399 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73400   unsigned int jresult ;
73401   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73402   unsigned int result;
73403
73404   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73405   {
73406     try {
73407       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73408     } catch (std::out_of_range& e) {
73409       {
73410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73411       };
73412     } catch (std::exception& e) {
73413       {
73414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73415       };
73416     } catch (Dali::DaliException e) {
73417       {
73418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73419       };
73420     } catch (...) {
73421       {
73422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73423       };
73424     }
73425   }
73426
73427   jresult = result;
73428   return jresult;
73429 }
73430
73431
73432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73433   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73434
73435   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73436   {
73437     try {
73438       delete arg1;
73439     } catch (std::out_of_range& e) {
73440       {
73441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73442       };
73443     } catch (std::exception& e) {
73444       {
73445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73446       };
73447     } catch (Dali::DaliException e) {
73448       {
73449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73450       };
73451     } catch (...) {
73452       {
73453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73454       };
73455     }
73456   }
73457
73458 }
73459
73460
73461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73462   void * jresult ;
73463   float arg1 ;
73464   Dali::Toolkit::FixedRuler *result = 0 ;
73465
73466   arg1 = (float)jarg1;
73467   {
73468     try {
73469       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73470     } catch (std::out_of_range& e) {
73471       {
73472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73473       };
73474     } catch (std::exception& e) {
73475       {
73476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73477       };
73478     } catch (Dali::DaliException e) {
73479       {
73480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73481       };
73482     } catch (...) {
73483       {
73484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73485       };
73486     }
73487   }
73488
73489   jresult = (void *)result;
73490   return jresult;
73491 }
73492
73493
73494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
73495   void * jresult ;
73496   Dali::Toolkit::FixedRuler *result = 0 ;
73497
73498   {
73499     try {
73500       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
73501     } catch (std::out_of_range& e) {
73502       {
73503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73504       };
73505     } catch (std::exception& e) {
73506       {
73507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73508       };
73509     } catch (Dali::DaliException e) {
73510       {
73511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73512       };
73513     } catch (...) {
73514       {
73515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73516       };
73517     }
73518   }
73519
73520   jresult = (void *)result;
73521   return jresult;
73522 }
73523
73524
73525 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73526   float jresult ;
73527   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73528   float arg2 ;
73529   float arg3 ;
73530   float result;
73531
73532   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73533   arg2 = (float)jarg2;
73534   arg3 = (float)jarg3;
73535   {
73536     try {
73537       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73538     } catch (std::out_of_range& e) {
73539       {
73540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73541       };
73542     } catch (std::exception& e) {
73543       {
73544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73545       };
73546     } catch (Dali::DaliException e) {
73547       {
73548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73549       };
73550     } catch (...) {
73551       {
73552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73553       };
73554     }
73555   }
73556
73557   jresult = result;
73558   return jresult;
73559 }
73560
73561
73562 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73563   float jresult ;
73564   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73565   unsigned int arg2 ;
73566   unsigned int *arg3 = 0 ;
73567   bool arg4 ;
73568   float result;
73569
73570   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73571   arg2 = (unsigned int)jarg2;
73572   arg3 = (unsigned int *)jarg3;
73573   arg4 = jarg4 ? true : false;
73574   {
73575     try {
73576       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73577     } catch (std::out_of_range& e) {
73578       {
73579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73580       };
73581     } catch (std::exception& e) {
73582       {
73583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73584       };
73585     } catch (Dali::DaliException e) {
73586       {
73587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73588       };
73589     } catch (...) {
73590       {
73591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73592       };
73593     }
73594   }
73595
73596   jresult = result;
73597   return jresult;
73598 }
73599
73600
73601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73602   unsigned int jresult ;
73603   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73604   float arg2 ;
73605   bool arg3 ;
73606   unsigned int result;
73607
73608   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73609   arg2 = (float)jarg2;
73610   arg3 = jarg3 ? true : false;
73611   {
73612     try {
73613       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73614     } catch (std::out_of_range& e) {
73615       {
73616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73617       };
73618     } catch (std::exception& e) {
73619       {
73620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73621       };
73622     } catch (Dali::DaliException e) {
73623       {
73624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73625       };
73626     } catch (...) {
73627       {
73628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73629       };
73630     }
73631   }
73632
73633   jresult = result;
73634   return jresult;
73635 }
73636
73637
73638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
73639   unsigned int jresult ;
73640   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73641   unsigned int result;
73642
73643   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73644   {
73645     try {
73646       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
73647     } catch (std::out_of_range& e) {
73648       {
73649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73650       };
73651     } catch (std::exception& e) {
73652       {
73653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73654       };
73655     } catch (Dali::DaliException e) {
73656       {
73657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73658       };
73659     } catch (...) {
73660       {
73661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73662       };
73663     }
73664   }
73665
73666   jresult = result;
73667   return jresult;
73668 }
73669
73670
73671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
73672   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73673
73674   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73675   {
73676     try {
73677       delete arg1;
73678     } catch (std::out_of_range& e) {
73679       {
73680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73681       };
73682     } catch (std::exception& e) {
73683       {
73684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73685       };
73686     } catch (Dali::DaliException e) {
73687       {
73688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73689       };
73690     } catch (...) {
73691       {
73692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73693       };
73694     }
73695   }
73696
73697 }
73698
73699
73700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
73701   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73702   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73703
73704   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73705   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73706   if (arg1) (arg1)->scale = *arg2;
73707 }
73708
73709
73710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
73711   void * jresult ;
73712   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73713   Dali::Toolkit::ClampState2D *result = 0 ;
73714
73715   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73716   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
73717   jresult = (void *)result;
73718   return jresult;
73719 }
73720
73721
73722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
73723   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73724   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73725
73726   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73727   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73728   if (arg1) (arg1)->position = *arg2;
73729 }
73730
73731
73732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
73733   void * jresult ;
73734   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73735   Dali::Toolkit::ClampState2D *result = 0 ;
73736
73737   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73738   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
73739   jresult = (void *)result;
73740   return jresult;
73741 }
73742
73743
73744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
73745   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73746   Dali::Toolkit::ClampState arg2 ;
73747
73748   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73749   arg2 = (Dali::Toolkit::ClampState)jarg2;
73750   if (arg1) (arg1)->rotation = arg2;
73751 }
73752
73753
73754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
73755   int jresult ;
73756   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73757   Dali::Toolkit::ClampState result;
73758
73759   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73760   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
73761   jresult = (int)result;
73762   return jresult;
73763 }
73764
73765
73766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
73767   void * jresult ;
73768   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
73769
73770   {
73771     try {
73772       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
73773     } catch (std::out_of_range& e) {
73774       {
73775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73776       };
73777     } catch (std::exception& e) {
73778       {
73779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73780       };
73781     } catch (Dali::DaliException e) {
73782       {
73783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73784       };
73785     } catch (...) {
73786       {
73787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73788       };
73789     }
73790   }
73791
73792   jresult = (void *)result;
73793   return jresult;
73794 }
73795
73796
73797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
73798   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73799
73800   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73801   {
73802     try {
73803       delete arg1;
73804     } catch (std::out_of_range& e) {
73805       {
73806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73807       };
73808     } catch (std::exception& e) {
73809       {
73810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73811       };
73812     } catch (Dali::DaliException e) {
73813       {
73814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73815       };
73816     } catch (...) {
73817       {
73818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73819       };
73820     }
73821   }
73822
73823 }
73824
73825
73826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
73827   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73828   Dali::Toolkit::SnapType arg2 ;
73829
73830   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73831   arg2 = (Dali::Toolkit::SnapType)jarg2;
73832   if (arg1) (arg1)->type = arg2;
73833 }
73834
73835
73836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
73837   int jresult ;
73838   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73839   Dali::Toolkit::SnapType result;
73840
73841   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73842   result = (Dali::Toolkit::SnapType) ((arg1)->type);
73843   jresult = (int)result;
73844   return jresult;
73845 }
73846
73847
73848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
73849   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73850   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
73851
73852   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73853   arg2 = (Dali::Vector2 *)jarg2;
73854   if (arg1) (arg1)->position = *arg2;
73855 }
73856
73857
73858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
73859   void * jresult ;
73860   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73861   Dali::Vector2 *result = 0 ;
73862
73863   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73864   result = (Dali::Vector2 *)& ((arg1)->position);
73865   jresult = (void *)result;
73866   return jresult;
73867 }
73868
73869
73870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
73871   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73872   float arg2 ;
73873
73874   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73875   arg2 = (float)jarg2;
73876   if (arg1) (arg1)->duration = arg2;
73877 }
73878
73879
73880 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
73881   float jresult ;
73882   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73883   float result;
73884
73885   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73886   result = (float) ((arg1)->duration);
73887   jresult = result;
73888   return jresult;
73889 }
73890
73891
73892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
73893   void * jresult ;
73894   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
73895
73896   {
73897     try {
73898       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
73899     } catch (std::out_of_range& e) {
73900       {
73901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73902       };
73903     } catch (std::exception& e) {
73904       {
73905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73906       };
73907     } catch (Dali::DaliException e) {
73908       {
73909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73910       };
73911     } catch (...) {
73912       {
73913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73914       };
73915     }
73916   }
73917
73918   jresult = (void *)result;
73919   return jresult;
73920 }
73921
73922
73923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
73924   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
73925
73926   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
73927   {
73928     try {
73929       delete arg1;
73930     } catch (std::out_of_range& e) {
73931       {
73932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73933       };
73934     } catch (std::exception& e) {
73935       {
73936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73937       };
73938     } catch (Dali::DaliException e) {
73939       {
73940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73941       };
73942     } catch (...) {
73943       {
73944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73945       };
73946     }
73947   }
73948
73949 }
73950
73951
73952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
73953   int jresult ;
73954   int result;
73955
73956   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
73957   jresult = (int)result;
73958   return jresult;
73959 }
73960
73961
73962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
73963   int jresult ;
73964   int result;
73965
73966   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
73967   jresult = (int)result;
73968   return jresult;
73969 }
73970
73971
73972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
73973   int jresult ;
73974   int result;
73975
73976   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
73977   jresult = (int)result;
73978   return jresult;
73979 }
73980
73981
73982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
73983   int jresult ;
73984   int result;
73985
73986   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
73987   jresult = (int)result;
73988   return jresult;
73989 }
73990
73991
73992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
73993   int jresult ;
73994   int result;
73995
73996   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
73997   jresult = (int)result;
73998   return jresult;
73999 }
74000
74001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
74002   int jresult ;
74003   int result;
74004
74005   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
74006   jresult = (int)result;
74007   return jresult;
74008 }
74009
74010
74011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
74012   int jresult ;
74013   int result;
74014
74015   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
74016   jresult = (int)result;
74017   return jresult;
74018 }
74019
74020
74021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
74022   int jresult ;
74023   int result;
74024
74025   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
74026   jresult = (int)result;
74027   return jresult;
74028 }
74029
74030
74031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
74032   int jresult ;
74033   int result;
74034
74035   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
74036   jresult = (int)result;
74037   return jresult;
74038 }
74039
74040
74041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74042   int jresult ;
74043   int result;
74044
74045   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74046   jresult = (int)result;
74047   return jresult;
74048 }
74049
74050
74051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74052   int jresult ;
74053   int result;
74054
74055   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74056   jresult = (int)result;
74057   return jresult;
74058 }
74059
74060
74061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74062   int jresult ;
74063   int result;
74064
74065   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74066   jresult = (int)result;
74067   return jresult;
74068 }
74069
74070
74071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74072   int jresult ;
74073   int result;
74074
74075   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74076   jresult = (int)result;
74077   return jresult;
74078 }
74079
74080
74081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74082   int jresult ;
74083   int result;
74084
74085   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74086   jresult = (int)result;
74087   return jresult;
74088 }
74089
74090
74091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74092   int jresult ;
74093   int result;
74094
74095   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74096   jresult = (int)result;
74097   return jresult;
74098 }
74099
74100
74101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74102   int jresult ;
74103   int result;
74104
74105   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74106   jresult = (int)result;
74107   return jresult;
74108 }
74109
74110
74111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74112   int jresult ;
74113   int result;
74114
74115   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74116   jresult = (int)result;
74117   return jresult;
74118 }
74119
74120
74121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74122   int jresult ;
74123   int result;
74124
74125   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74126   jresult = (int)result;
74127   return jresult;
74128 }
74129
74130
74131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74132   int jresult ;
74133   int result;
74134
74135   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74136   jresult = (int)result;
74137   return jresult;
74138 }
74139
74140
74141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74142   int jresult ;
74143   int result;
74144
74145   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74146   jresult = (int)result;
74147   return jresult;
74148 }
74149
74150
74151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74152   int jresult ;
74153   int result;
74154
74155   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74156   jresult = (int)result;
74157   return jresult;
74158 }
74159
74160
74161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74162   int jresult ;
74163   int result;
74164
74165   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74166   jresult = (int)result;
74167   return jresult;
74168 }
74169
74170
74171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74172   int jresult ;
74173   int result;
74174
74175   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74176   jresult = (int)result;
74177   return jresult;
74178 }
74179
74180
74181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74182   int jresult ;
74183   int result;
74184
74185   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74186   jresult = (int)result;
74187   return jresult;
74188 }
74189
74190
74191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74192   int jresult ;
74193   int result;
74194
74195   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74196   jresult = (int)result;
74197   return jresult;
74198 }
74199
74200
74201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74202   int jresult ;
74203   int result;
74204
74205   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74206   jresult = (int)result;
74207   return jresult;
74208 }
74209
74210
74211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74212   void * jresult ;
74213   Dali::Toolkit::ScrollView::Property *result = 0 ;
74214
74215   {
74216     try {
74217       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74218     } catch (std::out_of_range& e) {
74219       {
74220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74221       };
74222     } catch (std::exception& e) {
74223       {
74224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74225       };
74226     } catch (Dali::DaliException e) {
74227       {
74228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74229       };
74230     } catch (...) {
74231       {
74232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74233       };
74234     }
74235   }
74236
74237   jresult = (void *)result;
74238   return jresult;
74239 }
74240
74241
74242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74243   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74244
74245   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74246   {
74247     try {
74248       delete arg1;
74249     } catch (std::out_of_range& e) {
74250       {
74251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74252       };
74253     } catch (std::exception& e) {
74254       {
74255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74256       };
74257     } catch (Dali::DaliException e) {
74258       {
74259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74260       };
74261     } catch (...) {
74262       {
74263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74264       };
74265     }
74266   }
74267
74268 }
74269
74270
74271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74272   void * jresult ;
74273   Dali::Toolkit::ScrollView *result = 0 ;
74274
74275   {
74276     try {
74277       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74278     } catch (std::out_of_range& e) {
74279       {
74280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74281       };
74282     } catch (std::exception& e) {
74283       {
74284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74285       };
74286     } catch (Dali::DaliException e) {
74287       {
74288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74289       };
74290     } catch (...) {
74291       {
74292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74293       };
74294     }
74295   }
74296
74297   jresult = (void *)result;
74298   return jresult;
74299 }
74300
74301
74302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74303   void * jresult ;
74304   Dali::Toolkit::ScrollView *arg1 = 0 ;
74305   Dali::Toolkit::ScrollView *result = 0 ;
74306
74307   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74308   if (!arg1) {
74309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74310     return 0;
74311   }
74312   {
74313     try {
74314       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74315     } catch (std::out_of_range& e) {
74316       {
74317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74318       };
74319     } catch (std::exception& e) {
74320       {
74321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74322       };
74323     } catch (Dali::DaliException e) {
74324       {
74325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74326       };
74327     } catch (...) {
74328       {
74329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74330       };
74331     }
74332   }
74333
74334   jresult = (void *)result;
74335   return jresult;
74336 }
74337
74338
74339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74340   void * jresult ;
74341   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74342   Dali::Toolkit::ScrollView *arg2 = 0 ;
74343   Dali::Toolkit::ScrollView *result = 0 ;
74344
74345   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74346   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74347   if (!arg2) {
74348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74349     return 0;
74350   }
74351   {
74352     try {
74353       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74354     } catch (std::out_of_range& e) {
74355       {
74356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74357       };
74358     } catch (std::exception& e) {
74359       {
74360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74361       };
74362     } catch (Dali::DaliException e) {
74363       {
74364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74365       };
74366     } catch (...) {
74367       {
74368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74369       };
74370     }
74371   }
74372
74373   jresult = (void *)result;
74374   return jresult;
74375 }
74376
74377
74378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74379   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74380
74381   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74382   {
74383     try {
74384       delete arg1;
74385     } catch (std::out_of_range& e) {
74386       {
74387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74388       };
74389     } catch (std::exception& e) {
74390       {
74391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74392       };
74393     } catch (Dali::DaliException e) {
74394       {
74395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74396       };
74397     } catch (...) {
74398       {
74399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74400       };
74401     }
74402   }
74403
74404 }
74405
74406
74407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74408   void * jresult ;
74409   Dali::Toolkit::ScrollView result;
74410
74411   {
74412     try {
74413       result = Dali::Toolkit::ScrollView::New();
74414     } catch (std::out_of_range& e) {
74415       {
74416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74417       };
74418     } catch (std::exception& e) {
74419       {
74420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74421       };
74422     } catch (Dali::DaliException e) {
74423       {
74424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74425       };
74426     } catch (...) {
74427       {
74428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74429       };
74430     }
74431   }
74432
74433   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74434   return jresult;
74435 }
74436
74437
74438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74439   void * jresult ;
74440   Dali::BaseHandle arg1 ;
74441   Dali::BaseHandle *argp1 ;
74442   Dali::Toolkit::ScrollView result;
74443
74444   argp1 = (Dali::BaseHandle *)jarg1;
74445   if (!argp1) {
74446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74447     return 0;
74448   }
74449   arg1 = *argp1;
74450   {
74451     try {
74452       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74453     } catch (std::out_of_range& e) {
74454       {
74455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74456       };
74457     } catch (std::exception& e) {
74458       {
74459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74460       };
74461     } catch (Dali::DaliException e) {
74462       {
74463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74464       };
74465     } catch (...) {
74466       {
74467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74468       };
74469     }
74470   }
74471
74472   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74473   return jresult;
74474 }
74475
74476
74477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74478   void * jresult ;
74479   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74480   Dali::AlphaFunction result;
74481
74482   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74483   {
74484     try {
74485       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74486     } catch (std::out_of_range& e) {
74487       {
74488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74489       };
74490     } catch (std::exception& e) {
74491       {
74492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74493       };
74494     } catch (Dali::DaliException e) {
74495       {
74496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74497       };
74498     } catch (...) {
74499       {
74500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74501       };
74502     }
74503   }
74504
74505   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74506   return jresult;
74507 }
74508
74509
74510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74511   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74512   Dali::AlphaFunction arg2 ;
74513   Dali::AlphaFunction *argp2 ;
74514
74515   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74516   argp2 = (Dali::AlphaFunction *)jarg2;
74517   if (!argp2) {
74518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74519     return ;
74520   }
74521   arg2 = *argp2;
74522   {
74523     try {
74524       (arg1)->SetScrollSnapAlphaFunction(arg2);
74525     } catch (std::out_of_range& e) {
74526       {
74527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74528       };
74529     } catch (std::exception& e) {
74530       {
74531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74532       };
74533     } catch (Dali::DaliException e) {
74534       {
74535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74536       };
74537     } catch (...) {
74538       {
74539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74540       };
74541     }
74542   }
74543
74544 }
74545
74546
74547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74548   void * jresult ;
74549   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74550   Dali::AlphaFunction result;
74551
74552   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74553   {
74554     try {
74555       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
74556     } catch (std::out_of_range& e) {
74557       {
74558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74559       };
74560     } catch (std::exception& e) {
74561       {
74562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74563       };
74564     } catch (Dali::DaliException e) {
74565       {
74566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74567       };
74568     } catch (...) {
74569       {
74570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74571       };
74572     }
74573   }
74574
74575   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74576   return jresult;
74577 }
74578
74579
74580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74581   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74582   Dali::AlphaFunction arg2 ;
74583   Dali::AlphaFunction *argp2 ;
74584
74585   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74586   argp2 = (Dali::AlphaFunction *)jarg2;
74587   if (!argp2) {
74588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74589     return ;
74590   }
74591   arg2 = *argp2;
74592   {
74593     try {
74594       (arg1)->SetScrollFlickAlphaFunction(arg2);
74595     } catch (std::out_of_range& e) {
74596       {
74597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74598       };
74599     } catch (std::exception& e) {
74600       {
74601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74602       };
74603     } catch (Dali::DaliException e) {
74604       {
74605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74606       };
74607     } catch (...) {
74608       {
74609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74610       };
74611     }
74612   }
74613
74614 }
74615
74616
74617 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
74618   float jresult ;
74619   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74620   float result;
74621
74622   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74623   {
74624     try {
74625       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
74626     } catch (std::out_of_range& e) {
74627       {
74628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74629       };
74630     } catch (std::exception& e) {
74631       {
74632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74633       };
74634     } catch (Dali::DaliException e) {
74635       {
74636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74637       };
74638     } catch (...) {
74639       {
74640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74641       };
74642     }
74643   }
74644
74645   jresult = result;
74646   return jresult;
74647 }
74648
74649
74650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
74651   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74652   float arg2 ;
74653
74654   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74655   arg2 = (float)jarg2;
74656   {
74657     try {
74658       (arg1)->SetScrollSnapDuration(arg2);
74659     } catch (std::out_of_range& e) {
74660       {
74661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74662       };
74663     } catch (std::exception& e) {
74664       {
74665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74666       };
74667     } catch (Dali::DaliException e) {
74668       {
74669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74670       };
74671     } catch (...) {
74672       {
74673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74674       };
74675     }
74676   }
74677
74678 }
74679
74680
74681 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
74682   float jresult ;
74683   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74684   float result;
74685
74686   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74687   {
74688     try {
74689       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
74690     } catch (std::out_of_range& e) {
74691       {
74692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74693       };
74694     } catch (std::exception& e) {
74695       {
74696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74697       };
74698     } catch (Dali::DaliException e) {
74699       {
74700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74701       };
74702     } catch (...) {
74703       {
74704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74705       };
74706     }
74707   }
74708
74709   jresult = result;
74710   return jresult;
74711 }
74712
74713
74714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
74715   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74716   float arg2 ;
74717
74718   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74719   arg2 = (float)jarg2;
74720   {
74721     try {
74722       (arg1)->SetScrollFlickDuration(arg2);
74723     } catch (std::out_of_range& e) {
74724       {
74725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74726       };
74727     } catch (std::exception& e) {
74728       {
74729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74730       };
74731     } catch (Dali::DaliException e) {
74732       {
74733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74734       };
74735     } catch (...) {
74736       {
74737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74738       };
74739     }
74740   }
74741
74742 }
74743
74744
74745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
74746   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74747   Dali::Toolkit::RulerPtr arg2 ;
74748   Dali::Toolkit::RulerPtr *argp2 ;
74749
74750   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74751   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74752   if (!argp2) {
74753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74754     return ;
74755   }
74756   arg2 = *argp2;
74757   {
74758     try {
74759       (arg1)->SetRulerX(arg2);
74760     } catch (std::out_of_range& e) {
74761       {
74762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74763       };
74764     } catch (std::exception& e) {
74765       {
74766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74767       };
74768     } catch (Dali::DaliException e) {
74769       {
74770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74771       };
74772     } catch (...) {
74773       {
74774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74775       };
74776     }
74777   }
74778
74779 }
74780
74781
74782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
74783   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74784   Dali::Toolkit::RulerPtr arg2 ;
74785   Dali::Toolkit::RulerPtr *argp2 ;
74786
74787   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74788   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74789   if (!argp2) {
74790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74791     return ;
74792   }
74793   arg2 = *argp2;
74794   {
74795     try {
74796       (arg1)->SetRulerY(arg2);
74797     } catch (std::out_of_range& e) {
74798       {
74799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74800       };
74801     } catch (std::exception& e) {
74802       {
74803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74804       };
74805     } catch (Dali::DaliException e) {
74806       {
74807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74808       };
74809     } catch (...) {
74810       {
74811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74812       };
74813     }
74814   }
74815
74816 }
74817
74818
74819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
74820   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74821   bool arg2 ;
74822
74823   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74824   arg2 = jarg2 ? true : false;
74825   {
74826     try {
74827       (arg1)->SetScrollSensitive(arg2);
74828     } catch (std::out_of_range& e) {
74829       {
74830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74831       };
74832     } catch (std::exception& e) {
74833       {
74834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74835       };
74836     } catch (Dali::DaliException e) {
74837       {
74838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74839       };
74840     } catch (...) {
74841       {
74842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74843       };
74844     }
74845   }
74846
74847 }
74848
74849
74850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
74851   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74852   float arg2 ;
74853   float arg3 ;
74854
74855   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74856   arg2 = (float)jarg2;
74857   arg3 = (float)jarg3;
74858   {
74859     try {
74860       (arg1)->SetMaxOvershoot(arg2,arg3);
74861     } catch (std::out_of_range& e) {
74862       {
74863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74864       };
74865     } catch (std::exception& e) {
74866       {
74867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74868       };
74869     } catch (Dali::DaliException e) {
74870       {
74871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74872       };
74873     } catch (...) {
74874       {
74875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74876       };
74877     }
74878   }
74879
74880 }
74881
74882
74883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
74884   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74885   Dali::AlphaFunction arg2 ;
74886   Dali::AlphaFunction *argp2 ;
74887
74888   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74889   argp2 = (Dali::AlphaFunction *)jarg2;
74890   if (!argp2) {
74891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74892     return ;
74893   }
74894   arg2 = *argp2;
74895   {
74896     try {
74897       (arg1)->SetSnapOvershootAlphaFunction(arg2);
74898     } catch (std::out_of_range& e) {
74899       {
74900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74901       };
74902     } catch (std::exception& e) {
74903       {
74904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74905       };
74906     } catch (Dali::DaliException e) {
74907       {
74908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74909       };
74910     } catch (...) {
74911       {
74912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74913       };
74914     }
74915   }
74916
74917 }
74918
74919
74920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
74921   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74922   float arg2 ;
74923
74924   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74925   arg2 = (float)jarg2;
74926   {
74927     try {
74928       (arg1)->SetSnapOvershootDuration(arg2);
74929     } catch (std::out_of_range& e) {
74930       {
74931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74932       };
74933     } catch (std::exception& e) {
74934       {
74935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74936       };
74937     } catch (Dali::DaliException e) {
74938       {
74939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74940       };
74941     } catch (...) {
74942       {
74943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74944       };
74945     }
74946   }
74947
74948 }
74949
74950
74951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
74952   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74953   bool arg2 ;
74954
74955   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74956   arg2 = jarg2 ? true : false;
74957   {
74958     try {
74959       (arg1)->SetActorAutoSnap(arg2);
74960     } catch (std::out_of_range& e) {
74961       {
74962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74963       };
74964     } catch (std::exception& e) {
74965       {
74966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74967       };
74968     } catch (Dali::DaliException e) {
74969       {
74970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74971       };
74972     } catch (...) {
74973       {
74974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74975       };
74976     }
74977   }
74978
74979 }
74980
74981
74982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
74983   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74984   bool arg2 ;
74985
74986   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74987   arg2 = jarg2 ? true : false;
74988   {
74989     try {
74990       (arg1)->SetWrapMode(arg2);
74991     } catch (std::out_of_range& e) {
74992       {
74993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74994       };
74995     } catch (std::exception& e) {
74996       {
74997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74998       };
74999     } catch (Dali::DaliException e) {
75000       {
75001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75002       };
75003     } catch (...) {
75004       {
75005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75006       };
75007     }
75008   }
75009
75010 }
75011
75012
75013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
75014   int jresult ;
75015   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75016   int result;
75017
75018   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75019   {
75020     try {
75021       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
75022     } catch (std::out_of_range& e) {
75023       {
75024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75025       };
75026     } catch (std::exception& e) {
75027       {
75028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75029       };
75030     } catch (Dali::DaliException e) {
75031       {
75032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75033       };
75034     } catch (...) {
75035       {
75036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75037       };
75038     }
75039   }
75040
75041   jresult = result;
75042   return jresult;
75043 }
75044
75045
75046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
75047   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75048   int arg2 ;
75049
75050   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75051   arg2 = (int)jarg2;
75052   {
75053     try {
75054       (arg1)->SetScrollUpdateDistance(arg2);
75055     } catch (std::out_of_range& e) {
75056       {
75057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75058       };
75059     } catch (std::exception& e) {
75060       {
75061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75062       };
75063     } catch (Dali::DaliException e) {
75064       {
75065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75066       };
75067     } catch (...) {
75068       {
75069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75070       };
75071     }
75072   }
75073
75074 }
75075
75076
75077 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
75078   unsigned int jresult ;
75079   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75080   bool result;
75081
75082   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75083   {
75084     try {
75085       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
75086     } catch (std::out_of_range& e) {
75087       {
75088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75089       };
75090     } catch (std::exception& e) {
75091       {
75092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75093       };
75094     } catch (Dali::DaliException e) {
75095       {
75096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75097       };
75098     } catch (...) {
75099       {
75100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75101       };
75102     }
75103   }
75104
75105   jresult = result;
75106   return jresult;
75107 }
75108
75109
75110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
75111   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75112   bool arg2 ;
75113
75114   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75115   arg2 = jarg2 ? true : false;
75116   {
75117     try {
75118       (arg1)->SetAxisAutoLock(arg2);
75119     } catch (std::out_of_range& e) {
75120       {
75121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75122       };
75123     } catch (std::exception& e) {
75124       {
75125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75126       };
75127     } catch (Dali::DaliException e) {
75128       {
75129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75130       };
75131     } catch (...) {
75132       {
75133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75134       };
75135     }
75136   }
75137
75138 }
75139
75140
75141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
75142   float jresult ;
75143   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75144   float result;
75145
75146   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75147   {
75148     try {
75149       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
75150     } catch (std::out_of_range& e) {
75151       {
75152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75153       };
75154     } catch (std::exception& e) {
75155       {
75156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75157       };
75158     } catch (Dali::DaliException e) {
75159       {
75160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75161       };
75162     } catch (...) {
75163       {
75164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75165       };
75166     }
75167   }
75168
75169   jresult = result;
75170   return jresult;
75171 }
75172
75173
75174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
75175   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75176   float arg2 ;
75177
75178   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75179   arg2 = (float)jarg2;
75180   {
75181     try {
75182       (arg1)->SetAxisAutoLockGradient(arg2);
75183     } catch (std::out_of_range& e) {
75184       {
75185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75186       };
75187     } catch (std::exception& e) {
75188       {
75189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75190       };
75191     } catch (Dali::DaliException e) {
75192       {
75193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75194       };
75195     } catch (...) {
75196       {
75197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75198       };
75199     }
75200   }
75201
75202 }
75203
75204
75205 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
75206   float jresult ;
75207   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75208   float result;
75209
75210   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75211   {
75212     try {
75213       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75214     } catch (std::out_of_range& e) {
75215       {
75216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75217       };
75218     } catch (std::exception& e) {
75219       {
75220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75221       };
75222     } catch (Dali::DaliException e) {
75223       {
75224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75225       };
75226     } catch (...) {
75227       {
75228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75229       };
75230     }
75231   }
75232
75233   jresult = result;
75234   return jresult;
75235 }
75236
75237
75238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75239   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75240   float arg2 ;
75241
75242   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75243   arg2 = (float)jarg2;
75244   {
75245     try {
75246       (arg1)->SetFrictionCoefficient(arg2);
75247     } catch (std::out_of_range& e) {
75248       {
75249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75250       };
75251     } catch (std::exception& e) {
75252       {
75253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75254       };
75255     } catch (Dali::DaliException e) {
75256       {
75257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75258       };
75259     } catch (...) {
75260       {
75261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75262       };
75263     }
75264   }
75265
75266 }
75267
75268
75269 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75270   float jresult ;
75271   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75272   float result;
75273
75274   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75275   {
75276     try {
75277       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75278     } catch (std::out_of_range& e) {
75279       {
75280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75281       };
75282     } catch (std::exception& e) {
75283       {
75284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75285       };
75286     } catch (Dali::DaliException e) {
75287       {
75288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75289       };
75290     } catch (...) {
75291       {
75292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75293       };
75294     }
75295   }
75296
75297   jresult = result;
75298   return jresult;
75299 }
75300
75301
75302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75303   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75304   float arg2 ;
75305
75306   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75307   arg2 = (float)jarg2;
75308   {
75309     try {
75310       (arg1)->SetFlickSpeedCoefficient(arg2);
75311     } catch (std::out_of_range& e) {
75312       {
75313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75314       };
75315     } catch (std::exception& e) {
75316       {
75317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75318       };
75319     } catch (Dali::DaliException e) {
75320       {
75321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75322       };
75323     } catch (...) {
75324       {
75325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75326       };
75327     }
75328   }
75329
75330 }
75331
75332
75333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75334   void * jresult ;
75335   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75336   Dali::Vector2 result;
75337
75338   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75339   {
75340     try {
75341       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75342     } catch (std::out_of_range& e) {
75343       {
75344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75345       };
75346     } catch (std::exception& e) {
75347       {
75348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75349       };
75350     } catch (Dali::DaliException e) {
75351       {
75352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75353       };
75354     } catch (...) {
75355       {
75356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75357       };
75358     }
75359   }
75360
75361   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75362   return jresult;
75363 }
75364
75365
75366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75367   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75368   Dali::Vector2 *arg2 = 0 ;
75369
75370   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75371   arg2 = (Dali::Vector2 *)jarg2;
75372   if (!arg2) {
75373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75374     return ;
75375   }
75376   {
75377     try {
75378       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75379     } catch (std::out_of_range& e) {
75380       {
75381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75382       };
75383     } catch (std::exception& e) {
75384       {
75385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75386       };
75387     } catch (Dali::DaliException e) {
75388       {
75389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75390       };
75391     } catch (...) {
75392       {
75393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75394       };
75395     }
75396   }
75397
75398 }
75399
75400
75401 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75402   float jresult ;
75403   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75404   float result;
75405
75406   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75407   {
75408     try {
75409       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75410     } catch (std::out_of_range& e) {
75411       {
75412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75413       };
75414     } catch (std::exception& e) {
75415       {
75416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75417       };
75418     } catch (Dali::DaliException e) {
75419       {
75420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75421       };
75422     } catch (...) {
75423       {
75424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75425       };
75426     }
75427   }
75428
75429   jresult = result;
75430   return jresult;
75431 }
75432
75433
75434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75435   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75436   float arg2 ;
75437
75438   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75439   arg2 = (float)jarg2;
75440   {
75441     try {
75442       (arg1)->SetMinimumSpeedForFlick(arg2);
75443     } catch (std::out_of_range& e) {
75444       {
75445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75446       };
75447     } catch (std::exception& e) {
75448       {
75449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75450       };
75451     } catch (Dali::DaliException e) {
75452       {
75453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75454       };
75455     } catch (...) {
75456       {
75457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75458       };
75459     }
75460   }
75461
75462 }
75463
75464
75465 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75466   float jresult ;
75467   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75468   float result;
75469
75470   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75471   {
75472     try {
75473       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
75474     } catch (std::out_of_range& e) {
75475       {
75476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75477       };
75478     } catch (std::exception& e) {
75479       {
75480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75481       };
75482     } catch (Dali::DaliException e) {
75483       {
75484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75485       };
75486     } catch (...) {
75487       {
75488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75489       };
75490     }
75491   }
75492
75493   jresult = result;
75494   return jresult;
75495 }
75496
75497
75498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75499   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75500   float arg2 ;
75501
75502   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75503   arg2 = (float)jarg2;
75504   {
75505     try {
75506       (arg1)->SetMaxFlickSpeed(arg2);
75507     } catch (std::out_of_range& e) {
75508       {
75509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75510       };
75511     } catch (std::exception& e) {
75512       {
75513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75514       };
75515     } catch (Dali::DaliException e) {
75516       {
75517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75518       };
75519     } catch (...) {
75520       {
75521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75522       };
75523     }
75524   }
75525
75526 }
75527
75528
75529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75530   void * jresult ;
75531   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75532   Dali::Vector2 result;
75533
75534   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75535   {
75536     try {
75537       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75538     } catch (std::out_of_range& e) {
75539       {
75540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75541       };
75542     } catch (std::exception& e) {
75543       {
75544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75545       };
75546     } catch (Dali::DaliException e) {
75547       {
75548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75549       };
75550     } catch (...) {
75551       {
75552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75553       };
75554     }
75555   }
75556
75557   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75558   return jresult;
75559 }
75560
75561
75562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75563   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75564   Dali::Vector2 arg2 ;
75565   Dali::Vector2 *argp2 ;
75566
75567   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75568   argp2 = (Dali::Vector2 *)jarg2;
75569   if (!argp2) {
75570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75571     return ;
75572   }
75573   arg2 = *argp2;
75574   {
75575     try {
75576       (arg1)->SetWheelScrollDistanceStep(arg2);
75577     } catch (std::out_of_range& e) {
75578       {
75579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75580       };
75581     } catch (std::exception& e) {
75582       {
75583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75584       };
75585     } catch (Dali::DaliException e) {
75586       {
75587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75588       };
75589     } catch (...) {
75590       {
75591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75592       };
75593     }
75594   }
75595
75596 }
75597
75598
75599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
75600   void * jresult ;
75601   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75602   Dali::Vector2 result;
75603
75604   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75605   {
75606     try {
75607       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
75608     } catch (std::out_of_range& e) {
75609       {
75610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75611       };
75612     } catch (std::exception& e) {
75613       {
75614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75615       };
75616     } catch (Dali::DaliException e) {
75617       {
75618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75619       };
75620     } catch (...) {
75621       {
75622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75623       };
75624     }
75625   }
75626
75627   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75628   return jresult;
75629 }
75630
75631
75632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
75633   unsigned int jresult ;
75634   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75635   unsigned int result;
75636
75637   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75638   {
75639     try {
75640       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
75641     } catch (std::out_of_range& e) {
75642       {
75643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75644       };
75645     } catch (std::exception& e) {
75646       {
75647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75648       };
75649     } catch (Dali::DaliException e) {
75650       {
75651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75652       };
75653     } catch (...) {
75654       {
75655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75656       };
75657     }
75658   }
75659
75660   jresult = result;
75661   return jresult;
75662 }
75663
75664
75665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
75666   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75667   Dali::Vector2 *arg2 = 0 ;
75668
75669   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75670   arg2 = (Dali::Vector2 *)jarg2;
75671   if (!arg2) {
75672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75673     return ;
75674   }
75675   {
75676     try {
75677       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
75678     } catch (std::out_of_range& e) {
75679       {
75680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75681       };
75682     } catch (std::exception& e) {
75683       {
75684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75685       };
75686     } catch (Dali::DaliException e) {
75687       {
75688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75689       };
75690     } catch (...) {
75691       {
75692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75693       };
75694     }
75695   }
75696
75697 }
75698
75699
75700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
75701   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75702   Dali::Vector2 *arg2 = 0 ;
75703   float arg3 ;
75704
75705   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75706   arg2 = (Dali::Vector2 *)jarg2;
75707   if (!arg2) {
75708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75709     return ;
75710   }
75711   arg3 = (float)jarg3;
75712   {
75713     try {
75714       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
75715     } catch (std::out_of_range& e) {
75716       {
75717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75718       };
75719     } catch (std::exception& e) {
75720       {
75721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75722       };
75723     } catch (Dali::DaliException e) {
75724       {
75725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75726       };
75727     } catch (...) {
75728       {
75729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75730       };
75731     }
75732   }
75733
75734 }
75735
75736
75737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
75738   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75739   Dali::Vector2 *arg2 = 0 ;
75740   float arg3 ;
75741   Dali::AlphaFunction arg4 ;
75742   Dali::AlphaFunction *argp4 ;
75743
75744   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75745   arg2 = (Dali::Vector2 *)jarg2;
75746   if (!arg2) {
75747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75748     return ;
75749   }
75750   arg3 = (float)jarg3;
75751   argp4 = (Dali::AlphaFunction *)jarg4;
75752   if (!argp4) {
75753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75754     return ;
75755   }
75756   arg4 = *argp4;
75757   {
75758     try {
75759       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
75760     } catch (std::out_of_range& e) {
75761       {
75762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75763       };
75764     } catch (std::exception& e) {
75765       {
75766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75767       };
75768     } catch (Dali::DaliException e) {
75769       {
75770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75771       };
75772     } catch (...) {
75773       {
75774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75775       };
75776     }
75777   }
75778
75779 }
75780
75781
75782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
75783   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75784   Dali::Vector2 *arg2 = 0 ;
75785   float arg3 ;
75786   Dali::Toolkit::DirectionBias arg4 ;
75787   Dali::Toolkit::DirectionBias arg5 ;
75788
75789   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75790   arg2 = (Dali::Vector2 *)jarg2;
75791   if (!arg2) {
75792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75793     return ;
75794   }
75795   arg3 = (float)jarg3;
75796   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75797   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75798   {
75799     try {
75800       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
75801     } catch (std::out_of_range& e) {
75802       {
75803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75804       };
75805     } catch (std::exception& e) {
75806       {
75807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75808       };
75809     } catch (Dali::DaliException e) {
75810       {
75811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75812       };
75813     } catch (...) {
75814       {
75815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75816       };
75817     }
75818   }
75819
75820 }
75821
75822
75823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
75824   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75825   Dali::Vector2 *arg2 = 0 ;
75826   float arg3 ;
75827   Dali::AlphaFunction arg4 ;
75828   Dali::Toolkit::DirectionBias arg5 ;
75829   Dali::Toolkit::DirectionBias arg6 ;
75830   Dali::AlphaFunction *argp4 ;
75831
75832   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75833   arg2 = (Dali::Vector2 *)jarg2;
75834   if (!arg2) {
75835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75836     return ;
75837   }
75838   arg3 = (float)jarg3;
75839   argp4 = (Dali::AlphaFunction *)jarg4;
75840   if (!argp4) {
75841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75842     return ;
75843   }
75844   arg4 = *argp4;
75845   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75846   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
75847   {
75848     try {
75849       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
75850     } catch (std::out_of_range& e) {
75851       {
75852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75853       };
75854     } catch (std::exception& e) {
75855       {
75856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75857       };
75858     } catch (Dali::DaliException e) {
75859       {
75860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75861       };
75862     } catch (...) {
75863       {
75864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75865       };
75866     }
75867   }
75868
75869 }
75870
75871
75872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
75873   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75874   unsigned int arg2 ;
75875
75876   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75877   arg2 = (unsigned int)jarg2;
75878   {
75879     try {
75880       (arg1)->ScrollTo(arg2);
75881     } catch (std::out_of_range& e) {
75882       {
75883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75884       };
75885     } catch (std::exception& e) {
75886       {
75887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75888       };
75889     } catch (Dali::DaliException e) {
75890       {
75891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75892       };
75893     } catch (...) {
75894       {
75895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75896       };
75897     }
75898   }
75899
75900 }
75901
75902
75903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
75904   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75905   unsigned int arg2 ;
75906   float arg3 ;
75907
75908   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75909   arg2 = (unsigned int)jarg2;
75910   arg3 = (float)jarg3;
75911   {
75912     try {
75913       (arg1)->ScrollTo(arg2,arg3);
75914     } catch (std::out_of_range& e) {
75915       {
75916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75917       };
75918     } catch (std::exception& e) {
75919       {
75920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75921       };
75922     } catch (Dali::DaliException e) {
75923       {
75924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75925       };
75926     } catch (...) {
75927       {
75928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75929       };
75930     }
75931   }
75932
75933 }
75934
75935
75936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
75937   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75938   unsigned int arg2 ;
75939   float arg3 ;
75940   Dali::Toolkit::DirectionBias arg4 ;
75941
75942   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75943   arg2 = (unsigned int)jarg2;
75944   arg3 = (float)jarg3;
75945   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75946   {
75947     try {
75948       (arg1)->ScrollTo(arg2,arg3,arg4);
75949     } catch (std::out_of_range& e) {
75950       {
75951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75952       };
75953     } catch (std::exception& e) {
75954       {
75955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75956       };
75957     } catch (Dali::DaliException e) {
75958       {
75959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75960       };
75961     } catch (...) {
75962       {
75963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75964       };
75965     }
75966   }
75967
75968 }
75969
75970
75971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
75972   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75973   Dali::Actor *arg2 = 0 ;
75974
75975   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75976   arg2 = (Dali::Actor *)jarg2;
75977   if (!arg2) {
75978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75979     return ;
75980   }
75981   {
75982     try {
75983       (arg1)->ScrollTo(*arg2);
75984     } catch (std::out_of_range& e) {
75985       {
75986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75987       };
75988     } catch (std::exception& e) {
75989       {
75990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75991       };
75992     } catch (Dali::DaliException e) {
75993       {
75994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75995       };
75996     } catch (...) {
75997       {
75998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75999       };
76000     }
76001   }
76002
76003 }
76004
76005
76006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
76007   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76008   Dali::Actor *arg2 = 0 ;
76009   float arg3 ;
76010
76011   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76012   arg2 = (Dali::Actor *)jarg2;
76013   if (!arg2) {
76014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76015     return ;
76016   }
76017   arg3 = (float)jarg3;
76018   {
76019     try {
76020       (arg1)->ScrollTo(*arg2,arg3);
76021     } catch (std::out_of_range& e) {
76022       {
76023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76024       };
76025     } catch (std::exception& e) {
76026       {
76027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76028       };
76029     } catch (Dali::DaliException e) {
76030       {
76031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76032       };
76033     } catch (...) {
76034       {
76035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76036       };
76037     }
76038   }
76039
76040 }
76041
76042
76043 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
76044   unsigned int jresult ;
76045   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76046   bool result;
76047
76048   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76049   {
76050     try {
76051       result = (bool)(arg1)->ScrollToSnapPoint();
76052     } catch (std::out_of_range& e) {
76053       {
76054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76055       };
76056     } catch (std::exception& e) {
76057       {
76058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76059       };
76060     } catch (Dali::DaliException e) {
76061       {
76062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76063       };
76064     } catch (...) {
76065       {
76066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76067       };
76068     }
76069   }
76070
76071   jresult = result;
76072   return jresult;
76073 }
76074
76075
76076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
76077   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76078   Dali::Constraint arg2 ;
76079   Dali::Constraint *argp2 ;
76080
76081   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76082   argp2 = (Dali::Constraint *)jarg2;
76083   if (!argp2) {
76084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
76085     return ;
76086   }
76087   arg2 = *argp2;
76088   {
76089     try {
76090       (arg1)->ApplyConstraintToChildren(arg2);
76091     } catch (std::out_of_range& e) {
76092       {
76093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76094       };
76095     } catch (std::exception& e) {
76096       {
76097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76098       };
76099     } catch (Dali::DaliException e) {
76100       {
76101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76102       };
76103     } catch (...) {
76104       {
76105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76106       };
76107     }
76108   }
76109
76110 }
76111
76112
76113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
76114   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76115
76116   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76117   {
76118     try {
76119       (arg1)->RemoveConstraintsFromChildren();
76120     } catch (std::out_of_range& e) {
76121       {
76122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76123       };
76124     } catch (std::exception& e) {
76125       {
76126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76127       };
76128     } catch (Dali::DaliException e) {
76129       {
76130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76131       };
76132     } catch (...) {
76133       {
76134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76135       };
76136     }
76137   }
76138
76139 }
76140
76141
76142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
76143   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76144   Dali::Toolkit::ScrollViewEffect arg2 ;
76145   Dali::Toolkit::ScrollViewEffect *argp2 ;
76146
76147   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76148   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76149   if (!argp2) {
76150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76151     return ;
76152   }
76153   arg2 = *argp2;
76154   {
76155     try {
76156       (arg1)->ApplyEffect(arg2);
76157     } catch (std::out_of_range& e) {
76158       {
76159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76160       };
76161     } catch (std::exception& e) {
76162       {
76163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76164       };
76165     } catch (Dali::DaliException e) {
76166       {
76167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76168       };
76169     } catch (...) {
76170       {
76171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76172       };
76173     }
76174   }
76175
76176 }
76177
76178
76179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
76180   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76181   Dali::Toolkit::ScrollViewEffect arg2 ;
76182   Dali::Toolkit::ScrollViewEffect *argp2 ;
76183
76184   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76185   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76186   if (!argp2) {
76187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76188     return ;
76189   }
76190   arg2 = *argp2;
76191   {
76192     try {
76193       (arg1)->RemoveEffect(arg2);
76194     } catch (std::out_of_range& e) {
76195       {
76196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76197       };
76198     } catch (std::exception& e) {
76199       {
76200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76201       };
76202     } catch (Dali::DaliException e) {
76203       {
76204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76205       };
76206     } catch (...) {
76207       {
76208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76209       };
76210     }
76211   }
76212
76213 }
76214
76215
76216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
76217   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76218
76219   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76220   {
76221     try {
76222       (arg1)->RemoveAllEffects();
76223     } catch (std::out_of_range& e) {
76224       {
76225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76226       };
76227     } catch (std::exception& e) {
76228       {
76229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76230       };
76231     } catch (Dali::DaliException e) {
76232       {
76233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76234       };
76235     } catch (...) {
76236       {
76237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76238       };
76239     }
76240   }
76241
76242 }
76243
76244
76245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
76246   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76247   Dali::Actor arg2 ;
76248   Dali::Actor *argp2 ;
76249
76250   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76251   argp2 = (Dali::Actor *)jarg2;
76252   if (!argp2) {
76253     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76254     return ;
76255   }
76256   arg2 = *argp2;
76257   {
76258     try {
76259       (arg1)->BindActor(arg2);
76260     } catch (std::out_of_range& e) {
76261       {
76262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76263       };
76264     } catch (std::exception& e) {
76265       {
76266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76267       };
76268     } catch (Dali::DaliException e) {
76269       {
76270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76271       };
76272     } catch (...) {
76273       {
76274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76275       };
76276     }
76277   }
76278
76279 }
76280
76281
76282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
76283   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76284   Dali::Actor arg2 ;
76285   Dali::Actor *argp2 ;
76286
76287   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76288   argp2 = (Dali::Actor *)jarg2;
76289   if (!argp2) {
76290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76291     return ;
76292   }
76293   arg2 = *argp2;
76294   {
76295     try {
76296       (arg1)->UnbindActor(arg2);
76297     } catch (std::out_of_range& e) {
76298       {
76299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76300       };
76301     } catch (std::exception& e) {
76302       {
76303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76304       };
76305     } catch (Dali::DaliException e) {
76306       {
76307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76308       };
76309     } catch (...) {
76310       {
76311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76312       };
76313     }
76314   }
76315
76316 }
76317
76318
76319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
76320   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76321   Dali::Radian arg2 ;
76322   Dali::Radian arg3 ;
76323   Dali::Radian *argp2 ;
76324   Dali::Radian *argp3 ;
76325
76326   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76327   argp2 = (Dali::Radian *)jarg2;
76328   if (!argp2) {
76329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76330     return ;
76331   }
76332   arg2 = *argp2;
76333   argp3 = (Dali::Radian *)jarg3;
76334   if (!argp3) {
76335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76336     return ;
76337   }
76338   arg3 = *argp3;
76339   {
76340     try {
76341       (arg1)->SetScrollingDirection(arg2,arg3);
76342     } catch (std::out_of_range& e) {
76343       {
76344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76345       };
76346     } catch (std::exception& e) {
76347       {
76348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76349       };
76350     } catch (Dali::DaliException e) {
76351       {
76352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76353       };
76354     } catch (...) {
76355       {
76356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76357       };
76358     }
76359   }
76360
76361 }
76362
76363
76364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
76365   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76366   Dali::Radian arg2 ;
76367   Dali::Radian *argp2 ;
76368
76369   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76370   argp2 = (Dali::Radian *)jarg2;
76371   if (!argp2) {
76372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76373     return ;
76374   }
76375   arg2 = *argp2;
76376   {
76377     try {
76378       (arg1)->SetScrollingDirection(arg2);
76379     } catch (std::out_of_range& e) {
76380       {
76381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76382       };
76383     } catch (std::exception& e) {
76384       {
76385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76386       };
76387     } catch (Dali::DaliException e) {
76388       {
76389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76390       };
76391     } catch (...) {
76392       {
76393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76394       };
76395     }
76396   }
76397
76398 }
76399
76400
76401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76402   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76403   Dali::Radian arg2 ;
76404   Dali::Radian *argp2 ;
76405
76406   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76407   argp2 = (Dali::Radian *)jarg2;
76408   if (!argp2) {
76409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76410     return ;
76411   }
76412   arg2 = *argp2;
76413   {
76414     try {
76415       (arg1)->RemoveScrollingDirection(arg2);
76416     } catch (std::out_of_range& e) {
76417       {
76418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76419       };
76420     } catch (std::exception& e) {
76421       {
76422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76423       };
76424     } catch (Dali::DaliException e) {
76425       {
76426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76427       };
76428     } catch (...) {
76429       {
76430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76431       };
76432     }
76433   }
76434
76435 }
76436
76437
76438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76439   void * jresult ;
76440   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76441   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76442
76443   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76444   {
76445     try {
76446       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
76447     } catch (std::out_of_range& e) {
76448       {
76449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76450       };
76451     } catch (std::exception& e) {
76452       {
76453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76454       };
76455     } catch (Dali::DaliException e) {
76456       {
76457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76458       };
76459     } catch (...) {
76460       {
76461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76462       };
76463     }
76464   }
76465
76466   jresult = (void *)result;
76467   return jresult;
76468 }
76469
76470
76471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76472   int jresult ;
76473   int result;
76474
76475   result = (int)Dali::Toolkit::TableView::Property::ROWS;
76476   jresult = (int)result;
76477   return jresult;
76478 }
76479
76480
76481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
76482   int jresult ;
76483   int result;
76484
76485   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
76486   jresult = (int)result;
76487   return jresult;
76488 }
76489
76490
76491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
76492   int jresult ;
76493   int result;
76494
76495   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
76496   jresult = (int)result;
76497   return jresult;
76498 }
76499
76500
76501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
76502   int jresult ;
76503   int result;
76504
76505   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
76506   jresult = (int)result;
76507   return jresult;
76508 }
76509
76510
76511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
76512   int jresult ;
76513   int result;
76514
76515   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
76516   jresult = (int)result;
76517   return jresult;
76518 }
76519
76520
76521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
76522   void * jresult ;
76523   Dali::Toolkit::TableView::Property *result = 0 ;
76524
76525   {
76526     try {
76527       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
76528     } catch (std::out_of_range& e) {
76529       {
76530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76531       };
76532     } catch (std::exception& e) {
76533       {
76534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76535       };
76536     } catch (Dali::DaliException e) {
76537       {
76538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76539       };
76540     } catch (...) {
76541       {
76542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76543       };
76544     }
76545   }
76546
76547   jresult = (void *)result;
76548   return jresult;
76549 }
76550
76551
76552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
76553   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
76554
76555   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
76556   {
76557     try {
76558       delete arg1;
76559     } catch (std::out_of_range& e) {
76560       {
76561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76562       };
76563     } catch (std::exception& e) {
76564       {
76565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76566       };
76567     } catch (Dali::DaliException e) {
76568       {
76569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76570       };
76571     } catch (...) {
76572       {
76573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76574       };
76575     }
76576   }
76577
76578 }
76579
76580
76581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
76582   int jresult ;
76583   int result;
76584
76585   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
76586   jresult = (int)result;
76587   return jresult;
76588 }
76589
76590
76591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
76592   int jresult ;
76593   int result;
76594
76595   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
76596   jresult = (int)result;
76597   return jresult;
76598 }
76599
76600
76601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
76602   int jresult ;
76603   int result;
76604
76605   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
76606   jresult = (int)result;
76607   return jresult;
76608 }
76609
76610
76611 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
76612   int jresult ;
76613   int result;
76614
76615   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
76616   jresult = (int)result;
76617   return jresult;
76618 }
76619
76620
76621 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
76622   int jresult ;
76623   int result;
76624
76625   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
76626   jresult = (int)result;
76627   return jresult;
76628 }
76629
76630
76631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
76632   void * jresult ;
76633   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
76634
76635   {
76636     try {
76637       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
76638     } catch (std::out_of_range& e) {
76639       {
76640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76641       };
76642     } catch (std::exception& e) {
76643       {
76644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76645       };
76646     } catch (Dali::DaliException e) {
76647       {
76648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76649       };
76650     } catch (...) {
76651       {
76652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76653       };
76654     }
76655   }
76656
76657   jresult = (void *)result;
76658   return jresult;
76659 }
76660
76661
76662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
76663   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
76664
76665   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
76666   {
76667     try {
76668       delete arg1;
76669     } catch (std::out_of_range& e) {
76670       {
76671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76672       };
76673     } catch (std::exception& e) {
76674       {
76675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76676       };
76677     } catch (Dali::DaliException e) {
76678       {
76679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76680       };
76681     } catch (...) {
76682       {
76683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76684       };
76685     }
76686   }
76687
76688 }
76689
76690
76691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
76692   void * jresult ;
76693   unsigned int arg1 ;
76694   unsigned int arg2 ;
76695   unsigned int arg3 ;
76696   unsigned int arg4 ;
76697   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76698
76699   arg1 = (unsigned int)jarg1;
76700   arg2 = (unsigned int)jarg2;
76701   arg3 = (unsigned int)jarg3;
76702   arg4 = (unsigned int)jarg4;
76703   {
76704     try {
76705       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
76706     } catch (std::out_of_range& e) {
76707       {
76708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76709       };
76710     } catch (std::exception& e) {
76711       {
76712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76713       };
76714     } catch (Dali::DaliException e) {
76715       {
76716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76717       };
76718     } catch (...) {
76719       {
76720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76721       };
76722     }
76723   }
76724
76725   jresult = (void *)result;
76726   return jresult;
76727 }
76728
76729
76730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
76731   void * jresult ;
76732   unsigned int arg1 ;
76733   unsigned int arg2 ;
76734   unsigned int arg3 ;
76735   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76736
76737   arg1 = (unsigned int)jarg1;
76738   arg2 = (unsigned int)jarg2;
76739   arg3 = (unsigned int)jarg3;
76740   {
76741     try {
76742       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
76743     } catch (std::out_of_range& e) {
76744       {
76745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76746       };
76747     } catch (std::exception& e) {
76748       {
76749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76750       };
76751     } catch (Dali::DaliException e) {
76752       {
76753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76754       };
76755     } catch (...) {
76756       {
76757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76758       };
76759     }
76760   }
76761
76762   jresult = (void *)result;
76763   return jresult;
76764 }
76765
76766
76767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
76768   void * jresult ;
76769   unsigned int arg1 ;
76770   unsigned int arg2 ;
76771   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76772
76773   arg1 = (unsigned int)jarg1;
76774   arg2 = (unsigned int)jarg2;
76775   {
76776     try {
76777       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
76778     } catch (std::out_of_range& e) {
76779       {
76780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76781       };
76782     } catch (std::exception& e) {
76783       {
76784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76785       };
76786     } catch (Dali::DaliException e) {
76787       {
76788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76789       };
76790     } catch (...) {
76791       {
76792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76793       };
76794     }
76795   }
76796
76797   jresult = (void *)result;
76798   return jresult;
76799 }
76800
76801
76802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
76803   void * jresult ;
76804   unsigned int arg1 ;
76805   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76806
76807   arg1 = (unsigned int)jarg1;
76808   {
76809     try {
76810       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
76811     } catch (std::out_of_range& e) {
76812       {
76813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76814       };
76815     } catch (std::exception& e) {
76816       {
76817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76818       };
76819     } catch (Dali::DaliException e) {
76820       {
76821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76822       };
76823     } catch (...) {
76824       {
76825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76826       };
76827     }
76828   }
76829
76830   jresult = (void *)result;
76831   return jresult;
76832 }
76833
76834
76835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
76836   void * jresult ;
76837   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76838
76839   {
76840     try {
76841       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
76842     } catch (std::out_of_range& e) {
76843       {
76844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76845       };
76846     } catch (std::exception& e) {
76847       {
76848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76849       };
76850     } catch (Dali::DaliException e) {
76851       {
76852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76853       };
76854     } catch (...) {
76855       {
76856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76857       };
76858     }
76859   }
76860
76861   jresult = (void *)result;
76862   return jresult;
76863 }
76864
76865
76866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
76867   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76868   unsigned int arg2 ;
76869
76870   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76871   arg2 = (unsigned int)jarg2;
76872   if (arg1) (arg1)->rowIndex = arg2;
76873 }
76874
76875
76876 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
76877   unsigned int jresult ;
76878   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76879   unsigned int result;
76880
76881   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76882   result = (unsigned int) ((arg1)->rowIndex);
76883   jresult = result;
76884   return jresult;
76885 }
76886
76887
76888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
76889   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76890   unsigned int arg2 ;
76891
76892   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76893   arg2 = (unsigned int)jarg2;
76894   if (arg1) (arg1)->columnIndex = arg2;
76895 }
76896
76897
76898 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
76899   unsigned int jresult ;
76900   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76901   unsigned int result;
76902
76903   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76904   result = (unsigned int) ((arg1)->columnIndex);
76905   jresult = result;
76906   return jresult;
76907 }
76908
76909
76910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
76911   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76912   unsigned int arg2 ;
76913
76914   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76915   arg2 = (unsigned int)jarg2;
76916   if (arg1) (arg1)->rowSpan = arg2;
76917 }
76918
76919
76920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
76921   unsigned int jresult ;
76922   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76923   unsigned int result;
76924
76925   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76926   result = (unsigned int) ((arg1)->rowSpan);
76927   jresult = result;
76928   return jresult;
76929 }
76930
76931
76932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
76933   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76934   unsigned int arg2 ;
76935
76936   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76937   arg2 = (unsigned int)jarg2;
76938   if (arg1) (arg1)->columnSpan = arg2;
76939 }
76940
76941
76942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
76943   unsigned int jresult ;
76944   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76945   unsigned int result;
76946
76947   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76948   result = (unsigned int) ((arg1)->columnSpan);
76949   jresult = result;
76950   return jresult;
76951 }
76952
76953
76954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
76955   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
76956
76957   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
76958   {
76959     try {
76960       delete arg1;
76961     } catch (std::out_of_range& e) {
76962       {
76963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76964       };
76965     } catch (std::exception& e) {
76966       {
76967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76968       };
76969     } catch (Dali::DaliException e) {
76970       {
76971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76972       };
76973     } catch (...) {
76974       {
76975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76976       };
76977     }
76978   }
76979
76980 }
76981
76982
76983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
76984   void * jresult ;
76985   Dali::Toolkit::TableView *result = 0 ;
76986
76987   {
76988     try {
76989       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
76990     } catch (std::out_of_range& e) {
76991       {
76992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76993       };
76994     } catch (std::exception& e) {
76995       {
76996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76997       };
76998     } catch (Dali::DaliException e) {
76999       {
77000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77001       };
77002     } catch (...) {
77003       {
77004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77005       };
77006     }
77007   }
77008
77009   jresult = (void *)result;
77010   return jresult;
77011 }
77012
77013
77014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
77015   void * jresult ;
77016   Dali::Toolkit::TableView *arg1 = 0 ;
77017   Dali::Toolkit::TableView *result = 0 ;
77018
77019   arg1 = (Dali::Toolkit::TableView *)jarg1;
77020   if (!arg1) {
77021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77022     return 0;
77023   }
77024   {
77025     try {
77026       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
77027     } catch (std::out_of_range& e) {
77028       {
77029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77030       };
77031     } catch (std::exception& e) {
77032       {
77033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77034       };
77035     } catch (Dali::DaliException e) {
77036       {
77037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77038       };
77039     } catch (...) {
77040       {
77041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77042       };
77043     }
77044   }
77045
77046   jresult = (void *)result;
77047   return jresult;
77048 }
77049
77050
77051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
77052   void * jresult ;
77053   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77054   Dali::Toolkit::TableView *arg2 = 0 ;
77055   Dali::Toolkit::TableView *result = 0 ;
77056
77057   arg1 = (Dali::Toolkit::TableView *)jarg1;
77058   arg2 = (Dali::Toolkit::TableView *)jarg2;
77059   if (!arg2) {
77060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77061     return 0;
77062   }
77063   {
77064     try {
77065       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
77066     } catch (std::out_of_range& e) {
77067       {
77068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77069       };
77070     } catch (std::exception& e) {
77071       {
77072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77073       };
77074     } catch (Dali::DaliException e) {
77075       {
77076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77077       };
77078     } catch (...) {
77079       {
77080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77081       };
77082     }
77083   }
77084
77085   jresult = (void *)result;
77086   return jresult;
77087 }
77088
77089
77090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
77091   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77092
77093   arg1 = (Dali::Toolkit::TableView *)jarg1;
77094   {
77095     try {
77096       delete arg1;
77097     } catch (std::out_of_range& e) {
77098       {
77099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77100       };
77101     } catch (std::exception& e) {
77102       {
77103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77104       };
77105     } catch (Dali::DaliException e) {
77106       {
77107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77108       };
77109     } catch (...) {
77110       {
77111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77112       };
77113     }
77114   }
77115
77116 }
77117
77118
77119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
77120   void * jresult ;
77121   unsigned int arg1 ;
77122   unsigned int arg2 ;
77123   Dali::Toolkit::TableView result;
77124
77125   arg1 = (unsigned int)jarg1;
77126   arg2 = (unsigned int)jarg2;
77127   {
77128     try {
77129       result = Dali::Toolkit::TableView::New(arg1,arg2);
77130     } catch (std::out_of_range& e) {
77131       {
77132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77133       };
77134     } catch (std::exception& e) {
77135       {
77136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77137       };
77138     } catch (Dali::DaliException e) {
77139       {
77140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77141       };
77142     } catch (...) {
77143       {
77144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77145       };
77146     }
77147   }
77148
77149   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77150   return jresult;
77151 }
77152
77153
77154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
77155   void * jresult ;
77156   Dali::BaseHandle arg1 ;
77157   Dali::BaseHandle *argp1 ;
77158   Dali::Toolkit::TableView result;
77159
77160   argp1 = (Dali::BaseHandle *)jarg1;
77161   if (!argp1) {
77162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77163     return 0;
77164   }
77165   arg1 = *argp1;
77166   {
77167     try {
77168       result = Dali::Toolkit::TableView::DownCast(arg1);
77169     } catch (std::out_of_range& e) {
77170       {
77171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77172       };
77173     } catch (std::exception& e) {
77174       {
77175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77176       };
77177     } catch (Dali::DaliException e) {
77178       {
77179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77180       };
77181     } catch (...) {
77182       {
77183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77184       };
77185     }
77186   }
77187
77188   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77189   return jresult;
77190 }
77191
77192
77193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
77194   unsigned int jresult ;
77195   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77196   Dali::Actor arg2 ;
77197   Dali::Toolkit::TableView::CellPosition arg3 ;
77198   Dali::Actor *argp2 ;
77199   Dali::Toolkit::TableView::CellPosition *argp3 ;
77200   bool result;
77201
77202   arg1 = (Dali::Toolkit::TableView *)jarg1;
77203   argp2 = (Dali::Actor *)jarg2;
77204   if (!argp2) {
77205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77206     return 0;
77207   }
77208   arg2 = *argp2;
77209   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77210   if (!argp3) {
77211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77212     return 0;
77213   }
77214   arg3 = *argp3;
77215   {
77216     try {
77217       result = (bool)(arg1)->AddChild(arg2,arg3);
77218     } catch (std::out_of_range& e) {
77219       {
77220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77221       };
77222     } catch (std::exception& e) {
77223       {
77224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77225       };
77226     } catch (Dali::DaliException e) {
77227       {
77228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77229       };
77230     } catch (...) {
77231       {
77232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77233       };
77234     }
77235   }
77236
77237   jresult = result;
77238   return jresult;
77239 }
77240
77241
77242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
77243   void * jresult ;
77244   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77245   Dali::Toolkit::TableView::CellPosition arg2 ;
77246   Dali::Toolkit::TableView::CellPosition *argp2 ;
77247   Dali::Actor result;
77248
77249   arg1 = (Dali::Toolkit::TableView *)jarg1;
77250   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77251   if (!argp2) {
77252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77253     return 0;
77254   }
77255   arg2 = *argp2;
77256   {
77257     try {
77258       result = (arg1)->GetChildAt(arg2);
77259     } catch (std::out_of_range& e) {
77260       {
77261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77262       };
77263     } catch (std::exception& e) {
77264       {
77265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77266       };
77267     } catch (Dali::DaliException e) {
77268       {
77269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77270       };
77271     } catch (...) {
77272       {
77273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77274       };
77275     }
77276   }
77277
77278   jresult = new Dali::Actor((const Dali::Actor &)result);
77279   return jresult;
77280 }
77281
77282
77283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
77284   void * jresult ;
77285   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77286   Dali::Toolkit::TableView::CellPosition arg2 ;
77287   Dali::Toolkit::TableView::CellPosition *argp2 ;
77288   Dali::Actor result;
77289
77290   arg1 = (Dali::Toolkit::TableView *)jarg1;
77291   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77292   if (!argp2) {
77293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77294     return 0;
77295   }
77296   arg2 = *argp2;
77297   {
77298     try {
77299       result = (arg1)->RemoveChildAt(arg2);
77300     } catch (std::out_of_range& e) {
77301       {
77302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77303       };
77304     } catch (std::exception& e) {
77305       {
77306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77307       };
77308     } catch (Dali::DaliException e) {
77309       {
77310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77311       };
77312     } catch (...) {
77313       {
77314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77315       };
77316     }
77317   }
77318
77319   jresult = new Dali::Actor((const Dali::Actor &)result);
77320   return jresult;
77321 }
77322
77323
77324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
77325   unsigned int jresult ;
77326   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77327   Dali::Actor arg2 ;
77328   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
77329   Dali::Actor *argp2 ;
77330   bool result;
77331
77332   arg1 = (Dali::Toolkit::TableView *)jarg1;
77333   argp2 = (Dali::Actor *)jarg2;
77334   if (!argp2) {
77335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77336     return 0;
77337   }
77338   arg2 = *argp2;
77339   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77340   if (!arg3) {
77341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
77342     return 0;
77343   }
77344   {
77345     try {
77346       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
77347     } catch (std::out_of_range& e) {
77348       {
77349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77350       };
77351     } catch (std::exception& e) {
77352       {
77353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77354       };
77355     } catch (Dali::DaliException e) {
77356       {
77357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77358       };
77359     } catch (...) {
77360       {
77361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77362       };
77363     }
77364   }
77365
77366   jresult = result;
77367   return jresult;
77368 }
77369
77370
77371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
77372   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77373   unsigned int arg2 ;
77374
77375   arg1 = (Dali::Toolkit::TableView *)jarg1;
77376   arg2 = (unsigned int)jarg2;
77377   {
77378     try {
77379       (arg1)->InsertRow(arg2);
77380     } catch (std::out_of_range& e) {
77381       {
77382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77383       };
77384     } catch (std::exception& e) {
77385       {
77386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77387       };
77388     } catch (Dali::DaliException e) {
77389       {
77390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77391       };
77392     } catch (...) {
77393       {
77394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77395       };
77396     }
77397   }
77398
77399 }
77400
77401
77402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
77403   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77404   unsigned int arg2 ;
77405
77406   arg1 = (Dali::Toolkit::TableView *)jarg1;
77407   arg2 = (unsigned int)jarg2;
77408   {
77409     try {
77410       (arg1)->DeleteRow(arg2);
77411     } catch (std::out_of_range& e) {
77412       {
77413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77414       };
77415     } catch (std::exception& e) {
77416       {
77417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77418       };
77419     } catch (Dali::DaliException e) {
77420       {
77421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77422       };
77423     } catch (...) {
77424       {
77425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77426       };
77427     }
77428   }
77429
77430 }
77431
77432
77433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77434   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77435   unsigned int arg2 ;
77436   std::vector< Dali::Actor > *arg3 = 0 ;
77437
77438   arg1 = (Dali::Toolkit::TableView *)jarg1;
77439   arg2 = (unsigned int)jarg2;
77440   arg3 = (std::vector< Dali::Actor > *)jarg3;
77441   if (!arg3) {
77442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77443     return ;
77444   }
77445   {
77446     try {
77447       (arg1)->DeleteRow(arg2,*arg3);
77448     } catch (std::out_of_range& e) {
77449       {
77450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77451       };
77452     } catch (std::exception& e) {
77453       {
77454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77455       };
77456     } catch (Dali::DaliException e) {
77457       {
77458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77459       };
77460     } catch (...) {
77461       {
77462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77463       };
77464     }
77465   }
77466
77467 }
77468
77469
77470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
77471   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77472   unsigned int arg2 ;
77473
77474   arg1 = (Dali::Toolkit::TableView *)jarg1;
77475   arg2 = (unsigned int)jarg2;
77476   {
77477     try {
77478       (arg1)->InsertColumn(arg2);
77479     } catch (std::out_of_range& e) {
77480       {
77481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77482       };
77483     } catch (std::exception& e) {
77484       {
77485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77486       };
77487     } catch (Dali::DaliException e) {
77488       {
77489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77490       };
77491     } catch (...) {
77492       {
77493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77494       };
77495     }
77496   }
77497
77498 }
77499
77500
77501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
77502   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77503   unsigned int arg2 ;
77504
77505   arg1 = (Dali::Toolkit::TableView *)jarg1;
77506   arg2 = (unsigned int)jarg2;
77507   {
77508     try {
77509       (arg1)->DeleteColumn(arg2);
77510     } catch (std::out_of_range& e) {
77511       {
77512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77513       };
77514     } catch (std::exception& e) {
77515       {
77516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77517       };
77518     } catch (Dali::DaliException e) {
77519       {
77520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77521       };
77522     } catch (...) {
77523       {
77524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77525       };
77526     }
77527   }
77528
77529 }
77530
77531
77532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77533   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77534   unsigned int arg2 ;
77535   std::vector< Dali::Actor > *arg3 = 0 ;
77536
77537   arg1 = (Dali::Toolkit::TableView *)jarg1;
77538   arg2 = (unsigned int)jarg2;
77539   arg3 = (std::vector< Dali::Actor > *)jarg3;
77540   if (!arg3) {
77541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77542     return ;
77543   }
77544   {
77545     try {
77546       (arg1)->DeleteColumn(arg2,*arg3);
77547     } catch (std::out_of_range& e) {
77548       {
77549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77550       };
77551     } catch (std::exception& e) {
77552       {
77553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77554       };
77555     } catch (Dali::DaliException e) {
77556       {
77557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77558       };
77559     } catch (...) {
77560       {
77561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77562       };
77563     }
77564   }
77565
77566 }
77567
77568
77569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
77570   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77571   unsigned int arg2 ;
77572   unsigned int arg3 ;
77573
77574   arg1 = (Dali::Toolkit::TableView *)jarg1;
77575   arg2 = (unsigned int)jarg2;
77576   arg3 = (unsigned int)jarg3;
77577   {
77578     try {
77579       (arg1)->Resize(arg2,arg3);
77580     } catch (std::out_of_range& e) {
77581       {
77582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77583       };
77584     } catch (std::exception& e) {
77585       {
77586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77587       };
77588     } catch (Dali::DaliException e) {
77589       {
77590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77591       };
77592     } catch (...) {
77593       {
77594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77595       };
77596     }
77597   }
77598
77599 }
77600
77601
77602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
77603   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77604   unsigned int arg2 ;
77605   unsigned int arg3 ;
77606   std::vector< Dali::Actor > *arg4 = 0 ;
77607
77608   arg1 = (Dali::Toolkit::TableView *)jarg1;
77609   arg2 = (unsigned int)jarg2;
77610   arg3 = (unsigned int)jarg3;
77611   arg4 = (std::vector< Dali::Actor > *)jarg4;
77612   if (!arg4) {
77613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77614     return ;
77615   }
77616   {
77617     try {
77618       (arg1)->Resize(arg2,arg3,*arg4);
77619     } catch (std::out_of_range& e) {
77620       {
77621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77622       };
77623     } catch (std::exception& e) {
77624       {
77625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77626       };
77627     } catch (Dali::DaliException e) {
77628       {
77629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77630       };
77631     } catch (...) {
77632       {
77633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77634       };
77635     }
77636   }
77637
77638 }
77639
77640
77641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
77642   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77643   Dali::Size arg2 ;
77644   Dali::Size *argp2 ;
77645
77646   arg1 = (Dali::Toolkit::TableView *)jarg1;
77647   argp2 = (Dali::Size *)jarg2;
77648   if (!argp2) {
77649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
77650     return ;
77651   }
77652   arg2 = *argp2;
77653   {
77654     try {
77655       (arg1)->SetCellPadding(arg2);
77656     } catch (std::out_of_range& e) {
77657       {
77658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77659       };
77660     } catch (std::exception& e) {
77661       {
77662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77663       };
77664     } catch (Dali::DaliException e) {
77665       {
77666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77667       };
77668     } catch (...) {
77669       {
77670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77671       };
77672     }
77673   }
77674
77675 }
77676
77677
77678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
77679   void * jresult ;
77680   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77681   Dali::Size result;
77682
77683   arg1 = (Dali::Toolkit::TableView *)jarg1;
77684   {
77685     try {
77686       result = (arg1)->GetCellPadding();
77687     } catch (std::out_of_range& e) {
77688       {
77689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77690       };
77691     } catch (std::exception& e) {
77692       {
77693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77694       };
77695     } catch (Dali::DaliException e) {
77696       {
77697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77698       };
77699     } catch (...) {
77700       {
77701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77702       };
77703     }
77704   }
77705
77706   jresult = new Dali::Size((const Dali::Size &)result);
77707   return jresult;
77708 }
77709
77710
77711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
77712   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77713   unsigned int arg2 ;
77714
77715   arg1 = (Dali::Toolkit::TableView *)jarg1;
77716   arg2 = (unsigned int)jarg2;
77717   {
77718     try {
77719       (arg1)->SetFitHeight(arg2);
77720     } catch (std::out_of_range& e) {
77721       {
77722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77723       };
77724     } catch (std::exception& e) {
77725       {
77726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77727       };
77728     } catch (Dali::DaliException e) {
77729       {
77730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77731       };
77732     } catch (...) {
77733       {
77734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77735       };
77736     }
77737   }
77738
77739 }
77740
77741
77742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
77743   unsigned int jresult ;
77744   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77745   unsigned int arg2 ;
77746   bool result;
77747
77748   arg1 = (Dali::Toolkit::TableView *)jarg1;
77749   arg2 = (unsigned int)jarg2;
77750   {
77751     try {
77752       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
77753     } catch (std::out_of_range& e) {
77754       {
77755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77756       };
77757     } catch (std::exception& e) {
77758       {
77759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77760       };
77761     } catch (Dali::DaliException e) {
77762       {
77763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77764       };
77765     } catch (...) {
77766       {
77767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77768       };
77769     }
77770   }
77771
77772   jresult = result;
77773   return jresult;
77774 }
77775
77776
77777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
77778   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77779   unsigned int arg2 ;
77780
77781   arg1 = (Dali::Toolkit::TableView *)jarg1;
77782   arg2 = (unsigned int)jarg2;
77783   {
77784     try {
77785       (arg1)->SetFitWidth(arg2);
77786     } catch (std::out_of_range& e) {
77787       {
77788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77789       };
77790     } catch (std::exception& e) {
77791       {
77792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77793       };
77794     } catch (Dali::DaliException e) {
77795       {
77796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77797       };
77798     } catch (...) {
77799       {
77800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77801       };
77802     }
77803   }
77804
77805 }
77806
77807
77808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
77809   unsigned int jresult ;
77810   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77811   unsigned int arg2 ;
77812   bool result;
77813
77814   arg1 = (Dali::Toolkit::TableView *)jarg1;
77815   arg2 = (unsigned int)jarg2;
77816   {
77817     try {
77818       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
77819     } catch (std::out_of_range& e) {
77820       {
77821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77822       };
77823     } catch (std::exception& e) {
77824       {
77825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77826       };
77827     } catch (Dali::DaliException e) {
77828       {
77829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77830       };
77831     } catch (...) {
77832       {
77833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77834       };
77835     }
77836   }
77837
77838   jresult = result;
77839   return jresult;
77840 }
77841
77842
77843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77844   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77845   unsigned int arg2 ;
77846   float arg3 ;
77847
77848   arg1 = (Dali::Toolkit::TableView *)jarg1;
77849   arg2 = (unsigned int)jarg2;
77850   arg3 = (float)jarg3;
77851   {
77852     try {
77853       (arg1)->SetFixedHeight(arg2,arg3);
77854     } catch (std::out_of_range& e) {
77855       {
77856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77857       };
77858     } catch (std::exception& e) {
77859       {
77860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77861       };
77862     } catch (Dali::DaliException e) {
77863       {
77864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77865       };
77866     } catch (...) {
77867       {
77868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77869       };
77870     }
77871   }
77872
77873 }
77874
77875
77876 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
77877   float jresult ;
77878   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77879   unsigned int arg2 ;
77880   float result;
77881
77882   arg1 = (Dali::Toolkit::TableView *)jarg1;
77883   arg2 = (unsigned int)jarg2;
77884   {
77885     try {
77886       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
77887     } catch (std::out_of_range& e) {
77888       {
77889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77890       };
77891     } catch (std::exception& e) {
77892       {
77893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77894       };
77895     } catch (Dali::DaliException e) {
77896       {
77897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77898       };
77899     } catch (...) {
77900       {
77901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77902       };
77903     }
77904   }
77905
77906   jresult = result;
77907   return jresult;
77908 }
77909
77910
77911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
77912   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77913   unsigned int arg2 ;
77914   float arg3 ;
77915
77916   arg1 = (Dali::Toolkit::TableView *)jarg1;
77917   arg2 = (unsigned int)jarg2;
77918   arg3 = (float)jarg3;
77919   {
77920     try {
77921       (arg1)->SetRelativeHeight(arg2,arg3);
77922     } catch (std::out_of_range& e) {
77923       {
77924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77925       };
77926     } catch (std::exception& e) {
77927       {
77928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77929       };
77930     } catch (Dali::DaliException e) {
77931       {
77932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77933       };
77934     } catch (...) {
77935       {
77936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77937       };
77938     }
77939   }
77940
77941 }
77942
77943
77944 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
77945   float jresult ;
77946   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77947   unsigned int arg2 ;
77948   float result;
77949
77950   arg1 = (Dali::Toolkit::TableView *)jarg1;
77951   arg2 = (unsigned int)jarg2;
77952   {
77953     try {
77954       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
77955     } catch (std::out_of_range& e) {
77956       {
77957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77958       };
77959     } catch (std::exception& e) {
77960       {
77961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77962       };
77963     } catch (Dali::DaliException e) {
77964       {
77965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77966       };
77967     } catch (...) {
77968       {
77969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77970       };
77971     }
77972   }
77973
77974   jresult = result;
77975   return jresult;
77976 }
77977
77978
77979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
77980   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77981   unsigned int arg2 ;
77982   float arg3 ;
77983
77984   arg1 = (Dali::Toolkit::TableView *)jarg1;
77985   arg2 = (unsigned int)jarg2;
77986   arg3 = (float)jarg3;
77987   {
77988     try {
77989       (arg1)->SetFixedWidth(arg2,arg3);
77990     } catch (std::out_of_range& e) {
77991       {
77992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77993       };
77994     } catch (std::exception& e) {
77995       {
77996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77997       };
77998     } catch (Dali::DaliException e) {
77999       {
78000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78001       };
78002     } catch (...) {
78003       {
78004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78005       };
78006     }
78007   }
78008
78009 }
78010
78011
78012 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
78013   float jresult ;
78014   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78015   unsigned int arg2 ;
78016   float result;
78017
78018   arg1 = (Dali::Toolkit::TableView *)jarg1;
78019   arg2 = (unsigned int)jarg2;
78020   {
78021     try {
78022       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
78023     } catch (std::out_of_range& e) {
78024       {
78025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78026       };
78027     } catch (std::exception& e) {
78028       {
78029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78030       };
78031     } catch (Dali::DaliException e) {
78032       {
78033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78034       };
78035     } catch (...) {
78036       {
78037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78038       };
78039     }
78040   }
78041
78042   jresult = result;
78043   return jresult;
78044 }
78045
78046
78047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78048   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78049   unsigned int arg2 ;
78050   float arg3 ;
78051
78052   arg1 = (Dali::Toolkit::TableView *)jarg1;
78053   arg2 = (unsigned int)jarg2;
78054   arg3 = (float)jarg3;
78055   {
78056     try {
78057       (arg1)->SetRelativeWidth(arg2,arg3);
78058     } catch (std::out_of_range& e) {
78059       {
78060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78061       };
78062     } catch (std::exception& e) {
78063       {
78064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78065       };
78066     } catch (Dali::DaliException e) {
78067       {
78068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78069       };
78070     } catch (...) {
78071       {
78072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78073       };
78074     }
78075   }
78076
78077 }
78078
78079
78080 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
78081   float jresult ;
78082   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78083   unsigned int arg2 ;
78084   float result;
78085
78086   arg1 = (Dali::Toolkit::TableView *)jarg1;
78087   arg2 = (unsigned int)jarg2;
78088   {
78089     try {
78090       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
78091     } catch (std::out_of_range& e) {
78092       {
78093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78094       };
78095     } catch (std::exception& e) {
78096       {
78097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78098       };
78099     } catch (Dali::DaliException e) {
78100       {
78101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78102       };
78103     } catch (...) {
78104       {
78105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78106       };
78107     }
78108   }
78109
78110   jresult = result;
78111   return jresult;
78112 }
78113
78114
78115 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
78116   unsigned int jresult ;
78117   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78118   unsigned int result;
78119
78120   arg1 = (Dali::Toolkit::TableView *)jarg1;
78121   {
78122     try {
78123       result = (unsigned int)(arg1)->GetRows();
78124     } catch (std::out_of_range& e) {
78125       {
78126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78127       };
78128     } catch (std::exception& e) {
78129       {
78130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78131       };
78132     } catch (Dali::DaliException e) {
78133       {
78134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78135       };
78136     } catch (...) {
78137       {
78138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78139       };
78140     }
78141   }
78142
78143   jresult = result;
78144   return jresult;
78145 }
78146
78147
78148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
78149   unsigned int jresult ;
78150   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78151   unsigned int result;
78152
78153   arg1 = (Dali::Toolkit::TableView *)jarg1;
78154   {
78155     try {
78156       result = (unsigned int)(arg1)->GetColumns();
78157     } catch (std::out_of_range& e) {
78158       {
78159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78160       };
78161     } catch (std::exception& e) {
78162       {
78163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78164       };
78165     } catch (Dali::DaliException e) {
78166       {
78167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78168       };
78169     } catch (...) {
78170       {
78171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78172       };
78173     }
78174   }
78175
78176   jresult = result;
78177   return jresult;
78178 }
78179
78180
78181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
78182   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78183   Dali::Toolkit::TableView::CellPosition arg2 ;
78184   Dali::HorizontalAlignment::Type arg3 ;
78185   Dali::VerticalAlignment::Type arg4 ;
78186   Dali::Toolkit::TableView::CellPosition *argp2 ;
78187
78188   arg1 = (Dali::Toolkit::TableView *)jarg1;
78189   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
78190   if (!argp2) {
78191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
78192     return ;
78193   }
78194   arg2 = *argp2;
78195   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
78196   arg4 = (Dali::VerticalAlignment::Type)jarg4;
78197   {
78198     try {
78199       (arg1)->SetCellAlignment(arg2,arg3,arg4);
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_DEFAULT_RENDERING_BACKEND_get() {
78223   unsigned int jresult ;
78224   unsigned int result;
78225
78226   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
78227   jresult = result;
78228   return jresult;
78229 }
78230
78231
78232 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78233   int jresult ;
78234   int result;
78235
78236   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78237   jresult = (int)result;
78238   return jresult;
78239 }
78240
78241
78242 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78243   int jresult ;
78244   int result;
78245
78246   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78247   jresult = (int)result;
78248   return jresult;
78249 }
78250
78251
78252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78253   int jresult ;
78254   int result;
78255
78256   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78257   jresult = (int)result;
78258   return jresult;
78259 }
78260
78261
78262 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78263   int jresult ;
78264   int result;
78265
78266   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78267   jresult = (int)result;
78268   return jresult;
78269 }
78270
78271
78272 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78273   int jresult ;
78274   int result;
78275
78276   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78277   jresult = (int)result;
78278   return jresult;
78279 }
78280
78281
78282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78283   int jresult ;
78284   int result;
78285
78286   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78287   jresult = (int)result;
78288   return jresult;
78289 }
78290
78291
78292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78293   int jresult ;
78294   int result;
78295
78296   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78297   jresult = (int)result;
78298   return jresult;
78299 }
78300
78301
78302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78303   int jresult ;
78304   int result;
78305
78306   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78307   jresult = (int)result;
78308   return jresult;
78309 }
78310
78311
78312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78313   int jresult ;
78314   int result;
78315
78316   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78317   jresult = (int)result;
78318   return jresult;
78319 }
78320
78321
78322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78323   int jresult ;
78324   int result;
78325
78326   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78327   jresult = (int)result;
78328   return jresult;
78329 }
78330
78331
78332 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78333   int jresult ;
78334   int result;
78335
78336   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78337   jresult = (int)result;
78338   return jresult;
78339 }
78340
78341
78342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78343   int jresult ;
78344   int result;
78345
78346   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78347   jresult = (int)result;
78348   return jresult;
78349 }
78350
78351
78352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78353   int jresult ;
78354   int result;
78355
78356   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78357   jresult = (int)result;
78358   return jresult;
78359 }
78360
78361
78362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78363   int jresult ;
78364   int result;
78365
78366   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78367   jresult = (int)result;
78368   return jresult;
78369 }
78370
78371
78372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78373   int jresult ;
78374   int result;
78375
78376   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78377   jresult = (int)result;
78378   return jresult;
78379 }
78380
78381
78382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78383   int jresult ;
78384   int result;
78385
78386   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78387   jresult = (int)result;
78388   return jresult;
78389 }
78390
78391
78392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78393   int jresult ;
78394   int result;
78395
78396   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78397   jresult = (int)result;
78398   return jresult;
78399 }
78400
78401
78402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78403   int jresult ;
78404   int result;
78405
78406   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78407   jresult = (int)result;
78408   return jresult;
78409 }
78410
78411
78412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78413   void * jresult ;
78414   Dali::Toolkit::TextLabel::Property *result = 0 ;
78415
78416   {
78417     try {
78418       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78419     } catch (std::out_of_range& e) {
78420       {
78421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78422       };
78423     } catch (std::exception& e) {
78424       {
78425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78426       };
78427     } catch (Dali::DaliException e) {
78428       {
78429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78430       };
78431     } catch (...) {
78432       {
78433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78434       };
78435     }
78436   }
78437
78438   jresult = (void *)result;
78439   return jresult;
78440 }
78441
78442
78443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78444   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78445
78446   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78447   {
78448     try {
78449       delete arg1;
78450     } catch (std::out_of_range& e) {
78451       {
78452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78453       };
78454     } catch (std::exception& e) {
78455       {
78456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78457       };
78458     } catch (Dali::DaliException e) {
78459       {
78460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78461       };
78462     } catch (...) {
78463       {
78464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78465       };
78466     }
78467   }
78468
78469 }
78470
78471
78472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78473   void * jresult ;
78474   Dali::Toolkit::TextLabel result;
78475
78476   {
78477     try {
78478       result = Dali::Toolkit::TextLabel::New();
78479     } catch (std::out_of_range& e) {
78480       {
78481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78482       };
78483     } catch (std::exception& e) {
78484       {
78485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78486       };
78487     } catch (Dali::DaliException e) {
78488       {
78489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78490       };
78491     } catch (...) {
78492       {
78493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78494       };
78495     }
78496   }
78497
78498   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78499   return jresult;
78500 }
78501
78502
78503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78504   void * jresult ;
78505   std::string *arg1 = 0 ;
78506   Dali::Toolkit::TextLabel result;
78507
78508   if (!jarg1) {
78509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78510     return 0;
78511   }
78512   std::string arg1_str(jarg1);
78513   arg1 = &arg1_str;
78514   {
78515     try {
78516       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
78517     } catch (std::out_of_range& e) {
78518       {
78519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78520       };
78521     } catch (std::exception& e) {
78522       {
78523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78524       };
78525     } catch (Dali::DaliException e) {
78526       {
78527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78528       };
78529     } catch (...) {
78530       {
78531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78532       };
78533     }
78534   }
78535
78536   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78537
78538   //argout typemap for const std::string&
78539
78540   return jresult;
78541 }
78542
78543
78544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78545   void * jresult ;
78546   Dali::Toolkit::TextLabel *result = 0 ;
78547
78548   {
78549     try {
78550       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78551     } catch (std::out_of_range& e) {
78552       {
78553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78554       };
78555     } catch (std::exception& e) {
78556       {
78557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78558       };
78559     } catch (Dali::DaliException e) {
78560       {
78561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78562       };
78563     } catch (...) {
78564       {
78565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78566       };
78567     }
78568   }
78569
78570   jresult = (void *)result;
78571   return jresult;
78572 }
78573
78574
78575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78576   void * jresult ;
78577   Dali::Toolkit::TextLabel *arg1 = 0 ;
78578   Dali::Toolkit::TextLabel *result = 0 ;
78579
78580   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78581   if (!arg1) {
78582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78583     return 0;
78584   }
78585   {
78586     try {
78587       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78588     } catch (std::out_of_range& e) {
78589       {
78590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78591       };
78592     } catch (std::exception& e) {
78593       {
78594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78595       };
78596     } catch (Dali::DaliException e) {
78597       {
78598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78599       };
78600     } catch (...) {
78601       {
78602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78603       };
78604     }
78605   }
78606
78607   jresult = (void *)result;
78608   return jresult;
78609 }
78610
78611
78612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78613   void * jresult ;
78614   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78615   Dali::Toolkit::TextLabel *arg2 = 0 ;
78616   Dali::Toolkit::TextLabel *result = 0 ;
78617
78618   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78619   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78620   if (!arg2) {
78621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78622     return 0;
78623   }
78624   {
78625     try {
78626       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
78627     } catch (std::out_of_range& e) {
78628       {
78629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78630       };
78631     } catch (std::exception& e) {
78632       {
78633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78634       };
78635     } catch (Dali::DaliException e) {
78636       {
78637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78638       };
78639     } catch (...) {
78640       {
78641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78642       };
78643     }
78644   }
78645
78646   jresult = (void *)result;
78647   return jresult;
78648 }
78649
78650
78651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
78652   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78653
78654   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78655   {
78656     try {
78657       delete arg1;
78658     } catch (std::out_of_range& e) {
78659       {
78660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78661       };
78662     } catch (std::exception& e) {
78663       {
78664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78665       };
78666     } catch (Dali::DaliException e) {
78667       {
78668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78669       };
78670     } catch (...) {
78671       {
78672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78673       };
78674     }
78675   }
78676
78677 }
78678
78679
78680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
78681   void * jresult ;
78682   Dali::BaseHandle arg1 ;
78683   Dali::BaseHandle *argp1 ;
78684   Dali::Toolkit::TextLabel result;
78685
78686   argp1 = (Dali::BaseHandle *)jarg1;
78687   if (!argp1) {
78688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78689     return 0;
78690   }
78691   arg1 = *argp1;
78692   {
78693     try {
78694       result = Dali::Toolkit::TextLabel::DownCast(arg1);
78695     } catch (std::out_of_range& e) {
78696       {
78697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78698       };
78699     } catch (std::exception& e) {
78700       {
78701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78702       };
78703     } catch (Dali::DaliException e) {
78704       {
78705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78706       };
78707     } catch (...) {
78708       {
78709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78710       };
78711     }
78712   }
78713
78714   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78715   return jresult;
78716 }
78717
78718
78719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
78720   void * jresult ;
78721   Dali::Toolkit::AccessibilityManager *result = 0 ;
78722
78723   {
78724     try {
78725       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
78726     } catch (std::out_of_range& e) {
78727       {
78728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78729       };
78730     } catch (std::exception& e) {
78731       {
78732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78733       };
78734     } catch (Dali::DaliException e) {
78735       {
78736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78737       };
78738     } catch (...) {
78739       {
78740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78741       };
78742     }
78743   }
78744
78745   jresult = (void *)result;
78746   return jresult;
78747 }
78748
78749
78750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
78751   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78752
78753   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78754   {
78755     try {
78756       delete arg1;
78757     } catch (std::out_of_range& e) {
78758       {
78759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78760       };
78761     } catch (std::exception& e) {
78762       {
78763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78764       };
78765     } catch (Dali::DaliException e) {
78766       {
78767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78768       };
78769     } catch (...) {
78770       {
78771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78772       };
78773     }
78774   }
78775
78776 }
78777
78778
78779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
78780   void * jresult ;
78781   Dali::Toolkit::AccessibilityManager result;
78782
78783   {
78784     try {
78785       result = Dali::Toolkit::AccessibilityManager::Get();
78786     } catch (std::out_of_range& e) {
78787       {
78788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78789       };
78790     } catch (std::exception& e) {
78791       {
78792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78793       };
78794     } catch (Dali::DaliException e) {
78795       {
78796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78797       };
78798     } catch (...) {
78799       {
78800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78801       };
78802     }
78803   }
78804
78805   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
78806   return jresult;
78807 }
78808
78809
78810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
78811   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78812   Dali::Actor arg2 ;
78813   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78814   std::string *arg4 = 0 ;
78815   Dali::Actor *argp2 ;
78816
78817   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78818   argp2 = (Dali::Actor *)jarg2;
78819   if (!argp2) {
78820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78821     return ;
78822   }
78823   arg2 = *argp2;
78824   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78825   if (!jarg4) {
78826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78827     return ;
78828   }
78829   std::string arg4_str(jarg4);
78830   arg4 = &arg4_str;
78831   {
78832     try {
78833       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
78834     } catch (std::out_of_range& e) {
78835       {
78836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78837       };
78838     } catch (std::exception& e) {
78839       {
78840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78841       };
78842     } catch (Dali::DaliException e) {
78843       {
78844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78845       };
78846     } catch (...) {
78847       {
78848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78849       };
78850     }
78851   }
78852
78853
78854   //argout typemap for const std::string&
78855
78856 }
78857
78858
78859 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
78860   char * jresult ;
78861   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78862   Dali::Actor arg2 ;
78863   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78864   Dali::Actor *argp2 ;
78865   std::string result;
78866
78867   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78868   argp2 = (Dali::Actor *)jarg2;
78869   if (!argp2) {
78870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78871     return 0;
78872   }
78873   arg2 = *argp2;
78874   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78875   {
78876     try {
78877       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
78878     } catch (std::out_of_range& e) {
78879       {
78880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78881       };
78882     } catch (std::exception& e) {
78883       {
78884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78885       };
78886     } catch (Dali::DaliException e) {
78887       {
78888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78889       };
78890     } catch (...) {
78891       {
78892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78893       };
78894     }
78895   }
78896
78897   jresult = SWIG_csharp_string_callback((&result)->c_str());
78898   return jresult;
78899 }
78900
78901
78902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
78903   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78904   Dali::Actor arg2 ;
78905   unsigned int arg3 ;
78906   Dali::Actor *argp2 ;
78907
78908   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78909   argp2 = (Dali::Actor *)jarg2;
78910   if (!argp2) {
78911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78912     return ;
78913   }
78914   arg2 = *argp2;
78915   arg3 = (unsigned int)jarg3;
78916   {
78917     try {
78918       (arg1)->SetFocusOrder(arg2,arg3);
78919     } catch (std::out_of_range& e) {
78920       {
78921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78922       };
78923     } catch (std::exception& e) {
78924       {
78925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78926       };
78927     } catch (Dali::DaliException e) {
78928       {
78929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78930       };
78931     } catch (...) {
78932       {
78933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78934       };
78935     }
78936   }
78937
78938 }
78939
78940
78941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
78942   unsigned int jresult ;
78943   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78944   Dali::Actor arg2 ;
78945   Dali::Actor *argp2 ;
78946   unsigned int result;
78947
78948   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78949   argp2 = (Dali::Actor *)jarg2;
78950   if (!argp2) {
78951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78952     return 0;
78953   }
78954   arg2 = *argp2;
78955   {
78956     try {
78957       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
78958     } catch (std::out_of_range& e) {
78959       {
78960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78961       };
78962     } catch (std::exception& e) {
78963       {
78964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78965       };
78966     } catch (Dali::DaliException e) {
78967       {
78968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78969       };
78970     } catch (...) {
78971       {
78972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78973       };
78974     }
78975   }
78976
78977   jresult = result;
78978   return jresult;
78979 }
78980
78981
78982 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
78983   unsigned int jresult ;
78984   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78985   unsigned int result;
78986
78987   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78988   {
78989     try {
78990       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
78991     } catch (std::out_of_range& e) {
78992       {
78993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78994       };
78995     } catch (std::exception& e) {
78996       {
78997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78998       };
78999     } catch (Dali::DaliException e) {
79000       {
79001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79002       };
79003     } catch (...) {
79004       {
79005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79006       };
79007     }
79008   }
79009
79010   jresult = result;
79011   return jresult;
79012 }
79013
79014
79015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79016   void * jresult ;
79017   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79018   unsigned int arg2 ;
79019   Dali::Actor result;
79020
79021   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79022   arg2 = (unsigned int)jarg2;
79023   {
79024     try {
79025       result = (arg1)->GetActorByFocusOrder(arg2);
79026     } catch (std::out_of_range& e) {
79027       {
79028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79029       };
79030     } catch (std::exception& e) {
79031       {
79032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79033       };
79034     } catch (Dali::DaliException e) {
79035       {
79036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79037       };
79038     } catch (...) {
79039       {
79040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79041       };
79042     }
79043   }
79044
79045   jresult = new Dali::Actor((const Dali::Actor &)result);
79046   return jresult;
79047 }
79048
79049
79050 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79051   unsigned int jresult ;
79052   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79053   Dali::Actor arg2 ;
79054   Dali::Actor *argp2 ;
79055   bool result;
79056
79057   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79058   argp2 = (Dali::Actor *)jarg2;
79059   if (!argp2) {
79060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79061     return 0;
79062   }
79063   arg2 = *argp2;
79064   {
79065     try {
79066       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79067     } catch (std::out_of_range& e) {
79068       {
79069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79070       };
79071     } catch (std::exception& e) {
79072       {
79073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79074       };
79075     } catch (Dali::DaliException e) {
79076       {
79077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79078       };
79079     } catch (...) {
79080       {
79081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79082       };
79083     }
79084   }
79085
79086   jresult = result;
79087   return jresult;
79088 }
79089
79090
79091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79092   void * jresult ;
79093   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79094   Dali::Actor result;
79095
79096   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79097   {
79098     try {
79099       result = (arg1)->GetCurrentFocusActor();
79100     } catch (std::out_of_range& e) {
79101       {
79102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79103       };
79104     } catch (std::exception& e) {
79105       {
79106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79107       };
79108     } catch (Dali::DaliException e) {
79109       {
79110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79111       };
79112     } catch (...) {
79113       {
79114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79115       };
79116     }
79117   }
79118
79119   jresult = new Dali::Actor((const Dali::Actor &)result);
79120   return jresult;
79121 }
79122
79123
79124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79125   void * jresult ;
79126   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79127   Dali::Actor result;
79128
79129   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79130   {
79131     try {
79132       result = (arg1)->GetCurrentFocusGroup();
79133     } catch (std::out_of_range& e) {
79134       {
79135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79136       };
79137     } catch (std::exception& e) {
79138       {
79139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79140       };
79141     } catch (Dali::DaliException e) {
79142       {
79143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79144       };
79145     } catch (...) {
79146       {
79147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79148       };
79149     }
79150   }
79151
79152   jresult = new Dali::Actor((const Dali::Actor &)result);
79153   return jresult;
79154 }
79155
79156
79157 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79158   unsigned int jresult ;
79159   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79160   unsigned int result;
79161
79162   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79163   {
79164     try {
79165       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79166     } catch (std::out_of_range& e) {
79167       {
79168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79169       };
79170     } catch (std::exception& e) {
79171       {
79172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79173       };
79174     } catch (Dali::DaliException e) {
79175       {
79176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79177       };
79178     } catch (...) {
79179       {
79180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79181       };
79182     }
79183   }
79184
79185   jresult = result;
79186   return jresult;
79187 }
79188
79189
79190 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79191   unsigned int jresult ;
79192   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79193   bool result;
79194
79195   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79196   {
79197     try {
79198       result = (bool)(arg1)->MoveFocusForward();
79199     } catch (std::out_of_range& e) {
79200       {
79201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79202       };
79203     } catch (std::exception& e) {
79204       {
79205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79206       };
79207     } catch (Dali::DaliException e) {
79208       {
79209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79210       };
79211     } catch (...) {
79212       {
79213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79214       };
79215     }
79216   }
79217
79218   jresult = result;
79219   return jresult;
79220 }
79221
79222
79223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79224   unsigned int jresult ;
79225   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79226   bool result;
79227
79228   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79229   {
79230     try {
79231       result = (bool)(arg1)->MoveFocusBackward();
79232     } catch (std::out_of_range& e) {
79233       {
79234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79235       };
79236     } catch (std::exception& e) {
79237       {
79238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79239       };
79240     } catch (Dali::DaliException e) {
79241       {
79242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79243       };
79244     } catch (...) {
79245       {
79246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79247       };
79248     }
79249   }
79250
79251   jresult = result;
79252   return jresult;
79253 }
79254
79255
79256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79257   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79258
79259   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79260   {
79261     try {
79262       (arg1)->ClearFocus();
79263     } catch (std::out_of_range& e) {
79264       {
79265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79266       };
79267     } catch (std::exception& e) {
79268       {
79269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79270       };
79271     } catch (Dali::DaliException e) {
79272       {
79273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79274       };
79275     } catch (...) {
79276       {
79277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79278       };
79279     }
79280   }
79281
79282 }
79283
79284
79285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79286   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79287
79288   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79289   {
79290     try {
79291       (arg1)->Reset();
79292     } catch (std::out_of_range& e) {
79293       {
79294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79295       };
79296     } catch (std::exception& e) {
79297       {
79298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79299       };
79300     } catch (Dali::DaliException e) {
79301       {
79302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79303       };
79304     } catch (...) {
79305       {
79306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79307       };
79308     }
79309   }
79310
79311 }
79312
79313
79314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79315   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79316   Dali::Actor arg2 ;
79317   bool arg3 ;
79318   Dali::Actor *argp2 ;
79319
79320   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79321   argp2 = (Dali::Actor *)jarg2;
79322   if (!argp2) {
79323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79324     return ;
79325   }
79326   arg2 = *argp2;
79327   arg3 = jarg3 ? true : false;
79328   {
79329     try {
79330       (arg1)->SetFocusGroup(arg2,arg3);
79331     } catch (std::out_of_range& e) {
79332       {
79333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79334       };
79335     } catch (std::exception& e) {
79336       {
79337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79338       };
79339     } catch (Dali::DaliException e) {
79340       {
79341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79342       };
79343     } catch (...) {
79344       {
79345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79346       };
79347     }
79348   }
79349
79350 }
79351
79352
79353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79354   unsigned int jresult ;
79355   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79356   Dali::Actor arg2 ;
79357   Dali::Actor *argp2 ;
79358   bool result;
79359
79360   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79361   argp2 = (Dali::Actor *)jarg2;
79362   if (!argp2) {
79363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79364     return 0;
79365   }
79366   arg2 = *argp2;
79367   {
79368     try {
79369       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79370     } catch (std::out_of_range& e) {
79371       {
79372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79373       };
79374     } catch (std::exception& e) {
79375       {
79376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79377       };
79378     } catch (Dali::DaliException e) {
79379       {
79380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79381       };
79382     } catch (...) {
79383       {
79384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79385       };
79386     }
79387   }
79388
79389   jresult = result;
79390   return jresult;
79391 }
79392
79393
79394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79395   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79396   bool arg2 ;
79397
79398   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79399   arg2 = jarg2 ? true : false;
79400   {
79401     try {
79402       (arg1)->SetGroupMode(arg2);
79403     } catch (std::out_of_range& e) {
79404       {
79405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79406       };
79407     } catch (std::exception& e) {
79408       {
79409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79410       };
79411     } catch (Dali::DaliException e) {
79412       {
79413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79414       };
79415     } catch (...) {
79416       {
79417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79418       };
79419     }
79420   }
79421
79422 }
79423
79424
79425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79426   unsigned int jresult ;
79427   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79428   bool result;
79429
79430   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79431   {
79432     try {
79433       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79434     } catch (std::out_of_range& e) {
79435       {
79436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79437       };
79438     } catch (std::exception& e) {
79439       {
79440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79441       };
79442     } catch (Dali::DaliException e) {
79443       {
79444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79445       };
79446     } catch (...) {
79447       {
79448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79449       };
79450     }
79451   }
79452
79453   jresult = result;
79454   return jresult;
79455 }
79456
79457
79458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79459   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79460   bool arg2 ;
79461
79462   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79463   arg2 = jarg2 ? true : false;
79464   {
79465     try {
79466       (arg1)->SetWrapMode(arg2);
79467     } catch (std::out_of_range& e) {
79468       {
79469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79470       };
79471     } catch (std::exception& e) {
79472       {
79473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79474       };
79475     } catch (Dali::DaliException e) {
79476       {
79477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79478       };
79479     } catch (...) {
79480       {
79481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79482       };
79483     }
79484   }
79485
79486 }
79487
79488
79489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
79490   unsigned int jresult ;
79491   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79492   bool result;
79493
79494   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79495   {
79496     try {
79497       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
79498     } catch (std::out_of_range& e) {
79499       {
79500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79501       };
79502     } catch (std::exception& e) {
79503       {
79504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79505       };
79506     } catch (Dali::DaliException e) {
79507       {
79508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79509       };
79510     } catch (...) {
79511       {
79512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79513       };
79514     }
79515   }
79516
79517   jresult = result;
79518   return jresult;
79519 }
79520
79521
79522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
79523   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79524   Dali::Actor arg2 ;
79525   Dali::Actor *argp2 ;
79526
79527   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79528   argp2 = (Dali::Actor *)jarg2;
79529   if (!argp2) {
79530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79531     return ;
79532   }
79533   arg2 = *argp2;
79534   {
79535     try {
79536       (arg1)->SetFocusIndicatorActor(arg2);
79537     } catch (std::out_of_range& e) {
79538       {
79539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79540       };
79541     } catch (std::exception& e) {
79542       {
79543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79544       };
79545     } catch (Dali::DaliException e) {
79546       {
79547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79548       };
79549     } catch (...) {
79550       {
79551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79552       };
79553     }
79554   }
79555
79556 }
79557
79558
79559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
79560   void * jresult ;
79561   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79562   Dali::Actor result;
79563
79564   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79565   {
79566     try {
79567       result = (arg1)->GetFocusIndicatorActor();
79568     } catch (std::out_of_range& e) {
79569       {
79570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79571       };
79572     } catch (std::exception& e) {
79573       {
79574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79575       };
79576     } catch (Dali::DaliException e) {
79577       {
79578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79579       };
79580     } catch (...) {
79581       {
79582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79583       };
79584     }
79585   }
79586
79587   jresult = new Dali::Actor((const Dali::Actor &)result);
79588   return jresult;
79589 }
79590
79591
79592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
79593   void * jresult ;
79594   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79595   Dali::Actor arg2 ;
79596   Dali::Actor *argp2 ;
79597   Dali::Actor result;
79598
79599   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79600   argp2 = (Dali::Actor *)jarg2;
79601   if (!argp2) {
79602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79603     return 0;
79604   }
79605   arg2 = *argp2;
79606   {
79607     try {
79608       result = (arg1)->GetFocusGroup(arg2);
79609     } catch (std::out_of_range& e) {
79610       {
79611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79612       };
79613     } catch (std::exception& e) {
79614       {
79615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79616       };
79617     } catch (Dali::DaliException e) {
79618       {
79619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79620       };
79621     } catch (...) {
79622       {
79623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79624       };
79625     }
79626   }
79627
79628   jresult = new Dali::Actor((const Dali::Actor &)result);
79629   return jresult;
79630 }
79631
79632
79633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79634   void * jresult ;
79635   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79636   Dali::Vector2 result;
79637
79638   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79639   {
79640     try {
79641       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79642     } catch (std::out_of_range& e) {
79643       {
79644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79645       };
79646     } catch (std::exception& e) {
79647       {
79648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79649       };
79650     } catch (Dali::DaliException e) {
79651       {
79652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79653       };
79654     } catch (...) {
79655       {
79656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79657       };
79658     }
79659   }
79660
79661   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79662   return jresult;
79663 }
79664
79665
79666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
79667   void * jresult ;
79668   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79669   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
79670
79671   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79672   {
79673     try {
79674       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
79675     } catch (std::out_of_range& e) {
79676       {
79677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79678       };
79679     } catch (std::exception& e) {
79680       {
79681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79682       };
79683     } catch (Dali::DaliException e) {
79684       {
79685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79686       };
79687     } catch (...) {
79688       {
79689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79690       };
79691     }
79692   }
79693
79694   jresult = (void *)result;
79695   return jresult;
79696 }
79697
79698
79699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
79700   void * jresult ;
79701   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79702   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
79703
79704   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79705   {
79706     try {
79707       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
79708     } catch (std::out_of_range& e) {
79709       {
79710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79711       };
79712     } catch (std::exception& e) {
79713       {
79714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79715       };
79716     } catch (Dali::DaliException e) {
79717       {
79718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79719       };
79720     } catch (...) {
79721       {
79722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79723       };
79724     }
79725   }
79726
79727   jresult = (void *)result;
79728   return jresult;
79729 }
79730
79731
79732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
79733   void * jresult ;
79734   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79735   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
79736
79737   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79738   {
79739     try {
79740       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
79741     } catch (std::out_of_range& e) {
79742       {
79743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79744       };
79745     } catch (std::exception& e) {
79746       {
79747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79748       };
79749     } catch (Dali::DaliException e) {
79750       {
79751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79752       };
79753     } catch (...) {
79754       {
79755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79756       };
79757     }
79758   }
79759
79760   jresult = (void *)result;
79761   return jresult;
79762 }
79763
79764
79765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
79766   void * jresult ;
79767   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79768   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79769
79770   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79771   {
79772     try {
79773       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
79774     } catch (std::out_of_range& e) {
79775       {
79776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79777       };
79778     } catch (std::exception& e) {
79779       {
79780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79781       };
79782     } catch (Dali::DaliException e) {
79783       {
79784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79785       };
79786     } catch (...) {
79787       {
79788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79789       };
79790     }
79791   }
79792
79793   jresult = (void *)result;
79794   return jresult;
79795 }
79796
79797
79798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
79799   void * jresult ;
79800   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79801   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79802
79803   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79804   {
79805     try {
79806       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
79807     } catch (std::out_of_range& e) {
79808       {
79809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79810       };
79811     } catch (std::exception& e) {
79812       {
79813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79814       };
79815     } catch (Dali::DaliException e) {
79816       {
79817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79818       };
79819     } catch (...) {
79820       {
79821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79822       };
79823     }
79824   }
79825
79826   jresult = (void *)result;
79827   return jresult;
79828 }
79829
79830
79831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
79832   void * jresult ;
79833   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79834   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79835
79836   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79837   {
79838     try {
79839       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
79840     } catch (std::out_of_range& e) {
79841       {
79842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79843       };
79844     } catch (std::exception& e) {
79845       {
79846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79847       };
79848     } catch (Dali::DaliException e) {
79849       {
79850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79851       };
79852     } catch (...) {
79853       {
79854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79855       };
79856     }
79857   }
79858
79859   jresult = (void *)result;
79860   return jresult;
79861 }
79862
79863
79864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
79865   void * jresult ;
79866   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79867   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79868
79869   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79870   {
79871     try {
79872       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
79873     } catch (std::out_of_range& e) {
79874       {
79875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79876       };
79877     } catch (std::exception& e) {
79878       {
79879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79880       };
79881     } catch (Dali::DaliException e) {
79882       {
79883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79884       };
79885     } catch (...) {
79886       {
79887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79888       };
79889     }
79890   }
79891
79892   jresult = (void *)result;
79893   return jresult;
79894 }
79895
79896
79897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
79898   void * jresult ;
79899   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79900   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79901
79902   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79903   {
79904     try {
79905       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
79906     } catch (std::out_of_range& e) {
79907       {
79908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79909       };
79910     } catch (std::exception& e) {
79911       {
79912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79913       };
79914     } catch (Dali::DaliException e) {
79915       {
79916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79917       };
79918     } catch (...) {
79919       {
79920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79921       };
79922     }
79923   }
79924
79925   jresult = (void *)result;
79926   return jresult;
79927 }
79928
79929
79930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
79931   void * jresult ;
79932   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79933   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79934
79935   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79936   {
79937     try {
79938       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
79939     } catch (std::out_of_range& e) {
79940       {
79941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79942       };
79943     } catch (std::exception& e) {
79944       {
79945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79946       };
79947     } catch (Dali::DaliException e) {
79948       {
79949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79950       };
79951     } catch (...) {
79952       {
79953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79954       };
79955     }
79956   }
79957
79958   jresult = (void *)result;
79959   return jresult;
79960 }
79961
79962
79963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
79964   void * jresult ;
79965   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79966   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79967
79968   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79969   {
79970     try {
79971       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
79972     } catch (std::out_of_range& e) {
79973       {
79974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79975       };
79976     } catch (std::exception& e) {
79977       {
79978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79979       };
79980     } catch (Dali::DaliException e) {
79981       {
79982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79983       };
79984     } catch (...) {
79985       {
79986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79987       };
79988     }
79989   }
79990
79991   jresult = (void *)result;
79992   return jresult;
79993 }
79994
79995
79996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
79997   void * jresult ;
79998   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79999   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80000
80001   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80002   {
80003     try {
80004       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80005     } catch (std::out_of_range& e) {
80006       {
80007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80008       };
80009     } catch (std::exception& e) {
80010       {
80011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80012       };
80013     } catch (Dali::DaliException e) {
80014       {
80015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80016       };
80017     } catch (...) {
80018       {
80019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80020       };
80021     }
80022   }
80023
80024   jresult = (void *)result;
80025   return jresult;
80026 }
80027
80028
80029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80030   void * jresult ;
80031   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80032   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80033
80034   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80035   {
80036     try {
80037       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80038     } catch (std::out_of_range& e) {
80039       {
80040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80041       };
80042     } catch (std::exception& e) {
80043       {
80044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80045       };
80046     } catch (Dali::DaliException e) {
80047       {
80048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80049       };
80050     } catch (...) {
80051       {
80052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80053       };
80054     }
80055   }
80056
80057   jresult = (void *)result;
80058   return jresult;
80059 }
80060
80061
80062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80063   void * jresult ;
80064   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80065   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80066
80067   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80068   {
80069     try {
80070       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80071     } catch (std::out_of_range& e) {
80072       {
80073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80074       };
80075     } catch (std::exception& e) {
80076       {
80077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80078       };
80079     } catch (Dali::DaliException e) {
80080       {
80081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80082       };
80083     } catch (...) {
80084       {
80085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80086       };
80087     }
80088   }
80089
80090   jresult = (void *)result;
80091   return jresult;
80092 }
80093
80094
80095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80096   void * jresult ;
80097   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80098   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80099
80100   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80101   {
80102     try {
80103       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80104     } catch (std::out_of_range& e) {
80105       {
80106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80107       };
80108     } catch (std::exception& e) {
80109       {
80110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80111       };
80112     } catch (Dali::DaliException e) {
80113       {
80114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80115       };
80116     } catch (...) {
80117       {
80118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80119       };
80120     }
80121   }
80122
80123   jresult = (void *)result;
80124   return jresult;
80125 }
80126
80127
80128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
80129   void * jresult ;
80130   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80131   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80132
80133   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80134   {
80135     try {
80136       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80137     } catch (std::out_of_range& e) {
80138       {
80139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80140       };
80141     } catch (std::exception& e) {
80142       {
80143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80144       };
80145     } catch (Dali::DaliException e) {
80146       {
80147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80148       };
80149     } catch (...) {
80150       {
80151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80152       };
80153     }
80154   }
80155
80156   jresult = (void *)result;
80157   return jresult;
80158 }
80159
80160
80161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80162   void * jresult ;
80163   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80164   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80165
80166   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80167   {
80168     try {
80169       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80170     } catch (std::out_of_range& e) {
80171       {
80172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80173       };
80174     } catch (std::exception& e) {
80175       {
80176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80177       };
80178     } catch (Dali::DaliException e) {
80179       {
80180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80181       };
80182     } catch (...) {
80183       {
80184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80185       };
80186     }
80187   }
80188
80189   jresult = (void *)result;
80190   return jresult;
80191 }
80192
80193
80194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80195   void * jresult ;
80196   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80197   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80198
80199   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80200   {
80201     try {
80202       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80203     } catch (std::out_of_range& e) {
80204       {
80205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80206       };
80207     } catch (std::exception& e) {
80208       {
80209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80210       };
80211     } catch (Dali::DaliException e) {
80212       {
80213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80214       };
80215     } catch (...) {
80216       {
80217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80218       };
80219     }
80220   }
80221
80222   jresult = (void *)result;
80223   return jresult;
80224 }
80225
80226
80227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80228   void * jresult ;
80229   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80230   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80231
80232   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80233   {
80234     try {
80235       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80236     } catch (std::out_of_range& e) {
80237       {
80238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80239       };
80240     } catch (std::exception& e) {
80241       {
80242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80243       };
80244     } catch (Dali::DaliException e) {
80245       {
80246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80247       };
80248     } catch (...) {
80249       {
80250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80251       };
80252     }
80253   }
80254
80255   jresult = (void *)result;
80256   return jresult;
80257 }
80258
80259
80260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80261   void * jresult ;
80262   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80263   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80264
80265   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80266   {
80267     try {
80268       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80269     } catch (std::out_of_range& e) {
80270       {
80271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80272       };
80273     } catch (std::exception& e) {
80274       {
80275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80276       };
80277     } catch (Dali::DaliException e) {
80278       {
80279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80280       };
80281     } catch (...) {
80282       {
80283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80284       };
80285     }
80286   }
80287
80288   jresult = (void *)result;
80289   return jresult;
80290 }
80291
80292
80293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80294   void * jresult ;
80295   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80296   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80297
80298   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80299   {
80300     try {
80301       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
80302     } catch (std::out_of_range& e) {
80303       {
80304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80305       };
80306     } catch (std::exception& e) {
80307       {
80308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80309       };
80310     } catch (Dali::DaliException e) {
80311       {
80312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80313       };
80314     } catch (...) {
80315       {
80316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80317       };
80318     }
80319   }
80320
80321   jresult = (void *)result;
80322   return jresult;
80323 }
80324
80325
80326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
80327   void * jresult ;
80328   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80329   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80330
80331   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80332   {
80333     try {
80334       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
80335     } catch (std::out_of_range& e) {
80336       {
80337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80338       };
80339     } catch (std::exception& e) {
80340       {
80341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80342       };
80343     } catch (Dali::DaliException e) {
80344       {
80345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80346       };
80347     } catch (...) {
80348       {
80349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80350       };
80351     }
80352   }
80353
80354   jresult = (void *)result;
80355   return jresult;
80356 }
80357
80358
80359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80360   void * jresult ;
80361   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80362   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80363
80364   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80365   {
80366     try {
80367       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80368     } catch (std::out_of_range& e) {
80369       {
80370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80371       };
80372     } catch (std::exception& e) {
80373       {
80374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80375       };
80376     } catch (Dali::DaliException e) {
80377       {
80378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80379       };
80380     } catch (...) {
80381       {
80382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80383       };
80384     }
80385   }
80386
80387   jresult = (void *)result;
80388   return jresult;
80389 }
80390
80391
80392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80393   void * jresult ;
80394   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80395   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80396
80397   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80398   {
80399     try {
80400       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80401     } catch (std::out_of_range& e) {
80402       {
80403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80404       };
80405     } catch (std::exception& e) {
80406       {
80407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80408       };
80409     } catch (Dali::DaliException e) {
80410       {
80411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80412       };
80413     } catch (...) {
80414       {
80415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80416       };
80417     }
80418   }
80419
80420   jresult = (void *)result;
80421   return jresult;
80422 }
80423
80424
80425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80426   void * jresult ;
80427   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80428   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80429
80430   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80431   {
80432     try {
80433       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80434     } catch (std::out_of_range& e) {
80435       {
80436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80437       };
80438     } catch (std::exception& e) {
80439       {
80440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80441       };
80442     } catch (Dali::DaliException e) {
80443       {
80444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80445       };
80446     } catch (...) {
80447       {
80448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80449       };
80450     }
80451   }
80452
80453   jresult = (void *)result;
80454   return jresult;
80455 }
80456
80457
80458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80459   void * jresult ;
80460   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80461   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80462
80463   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80464   {
80465     try {
80466       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80467     } catch (std::out_of_range& e) {
80468       {
80469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80470       };
80471     } catch (std::exception& e) {
80472       {
80473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80474       };
80475     } catch (Dali::DaliException e) {
80476       {
80477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80478       };
80479     } catch (...) {
80480       {
80481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80482       };
80483     }
80484   }
80485
80486   jresult = (void *)result;
80487   return jresult;
80488 }
80489
80490
80491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80492   void * jresult ;
80493   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80494   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80495
80496   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80497   {
80498     try {
80499       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80500     } catch (std::out_of_range& e) {
80501       {
80502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80503       };
80504     } catch (std::exception& e) {
80505       {
80506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80507       };
80508     } catch (Dali::DaliException e) {
80509       {
80510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80511       };
80512     } catch (...) {
80513       {
80514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80515       };
80516     }
80517   }
80518
80519   jresult = (void *)result;
80520   return jresult;
80521 }
80522
80523
80524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
80525   void * jresult ;
80526   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80527   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80528
80529   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80530   {
80531     try {
80532       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
80533     } catch (std::out_of_range& e) {
80534       {
80535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80536       };
80537     } catch (std::exception& e) {
80538       {
80539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80540       };
80541     } catch (Dali::DaliException e) {
80542       {
80543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80544       };
80545     } catch (...) {
80546       {
80547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80548       };
80549     }
80550   }
80551
80552   jresult = (void *)result;
80553   return jresult;
80554 }
80555
80556
80557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
80558   void * jresult ;
80559   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80560   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80561
80562   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80563   {
80564     try {
80565       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
80566     } catch (std::out_of_range& e) {
80567       {
80568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80569       };
80570     } catch (std::exception& e) {
80571       {
80572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80573       };
80574     } catch (Dali::DaliException e) {
80575       {
80576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80577       };
80578     } catch (...) {
80579       {
80580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80581       };
80582     }
80583   }
80584
80585   jresult = (void *)result;
80586   return jresult;
80587 }
80588
80589
80590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
80591   void * jresult ;
80592   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80593   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
80594
80595   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80596   {
80597     try {
80598       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
80599     } catch (std::out_of_range& e) {
80600       {
80601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80602       };
80603     } catch (std::exception& e) {
80604       {
80605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80606       };
80607     } catch (Dali::DaliException e) {
80608       {
80609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80610       };
80611     } catch (...) {
80612       {
80613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80614       };
80615     }
80616   }
80617
80618   jresult = (void *)result;
80619   return jresult;
80620 }
80621
80622
80623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
80624   void * jresult ;
80625   Dali::Toolkit::StyleManager *result = 0 ;
80626
80627   {
80628     try {
80629       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
80630     } catch (std::out_of_range& e) {
80631       {
80632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80633       };
80634     } catch (std::exception& e) {
80635       {
80636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80637       };
80638     } catch (Dali::DaliException e) {
80639       {
80640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80641       };
80642     } catch (...) {
80643       {
80644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80645       };
80646     }
80647   }
80648
80649   jresult = (void *)result;
80650   return jresult;
80651 }
80652
80653
80654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
80655   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80656
80657   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80658   {
80659     try {
80660       delete arg1;
80661     } catch (std::out_of_range& e) {
80662       {
80663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80664       };
80665     } catch (std::exception& e) {
80666       {
80667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80668       };
80669     } catch (Dali::DaliException e) {
80670       {
80671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80672       };
80673     } catch (...) {
80674       {
80675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80676       };
80677     }
80678   }
80679
80680 }
80681
80682
80683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
80684   void * jresult ;
80685   Dali::Toolkit::StyleManager result;
80686
80687   {
80688     try {
80689       result = Dali::Toolkit::StyleManager::Get();
80690     } catch (std::out_of_range& e) {
80691       {
80692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80693       };
80694     } catch (std::exception& e) {
80695       {
80696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80697       };
80698     } catch (Dali::DaliException e) {
80699       {
80700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80701       };
80702     } catch (...) {
80703       {
80704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80705       };
80706     }
80707   }
80708
80709   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
80710   return jresult;
80711 }
80712
80713
80714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
80715   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80716   std::string *arg2 = 0 ;
80717
80718   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80719   if (!jarg2) {
80720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80721     return ;
80722   }
80723   std::string arg2_str(jarg2);
80724   arg2 = &arg2_str;
80725   {
80726     try {
80727       (arg1)->ApplyTheme((std::string const &)*arg2);
80728     } catch (std::out_of_range& e) {
80729       {
80730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80731       };
80732     } catch (std::exception& e) {
80733       {
80734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80735       };
80736     } catch (Dali::DaliException e) {
80737       {
80738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80739       };
80740     } catch (...) {
80741       {
80742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80743       };
80744     }
80745   }
80746
80747
80748   //argout typemap for const std::string&
80749
80750 }
80751
80752
80753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
80754   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80755
80756   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80757   {
80758     try {
80759       (arg1)->ApplyDefaultTheme();
80760     } catch (std::out_of_range& e) {
80761       {
80762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80763       };
80764     } catch (std::exception& e) {
80765       {
80766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80767       };
80768     } catch (Dali::DaliException e) {
80769       {
80770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80771       };
80772     } catch (...) {
80773       {
80774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80775       };
80776     }
80777   }
80778
80779 }
80780
80781
80782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80783   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80784   std::string *arg2 = 0 ;
80785   Dali::Property::Value *arg3 = 0 ;
80786
80787   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80788   if (!jarg2) {
80789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80790     return ;
80791   }
80792   std::string arg2_str(jarg2);
80793   arg2 = &arg2_str;
80794   arg3 = (Dali::Property::Value *)jarg3;
80795   if (!arg3) {
80796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
80797     return ;
80798   }
80799   {
80800     try {
80801       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
80802     } catch (std::out_of_range& e) {
80803       {
80804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80805       };
80806     } catch (std::exception& e) {
80807       {
80808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80809       };
80810     } catch (Dali::DaliException e) {
80811       {
80812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80813       };
80814     } catch (...) {
80815       {
80816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80817       };
80818     }
80819   }
80820
80821
80822   //argout typemap for const std::string&
80823
80824 }
80825
80826
80827 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80828   unsigned int jresult ;
80829   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80830   std::string *arg2 = 0 ;
80831   Dali::Property::Value *arg3 = 0 ;
80832   bool result;
80833
80834   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80835   if (!jarg2) {
80836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80837     return 0;
80838   }
80839   std::string arg2_str(jarg2);
80840   arg2 = &arg2_str;
80841   arg3 = (Dali::Property::Value *)jarg3;
80842   if (!arg3) {
80843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
80844     return 0;
80845   }
80846   {
80847     try {
80848       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
80849     } catch (std::out_of_range& e) {
80850       {
80851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80852       };
80853     } catch (std::exception& e) {
80854       {
80855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80856       };
80857     } catch (Dali::DaliException e) {
80858       {
80859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80860       };
80861     } catch (...) {
80862       {
80863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80864       };
80865     }
80866   }
80867
80868   jresult = result;
80869
80870   //argout typemap for const std::string&
80871
80872   return jresult;
80873 }
80874
80875
80876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
80877   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80878   Dali::Toolkit::Control arg2 ;
80879   std::string *arg3 = 0 ;
80880   std::string *arg4 = 0 ;
80881   Dali::Toolkit::Control *argp2 ;
80882
80883   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80884   argp2 = (Dali::Toolkit::Control *)jarg2;
80885   if (!argp2) {
80886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
80887     return ;
80888   }
80889   arg2 = *argp2;
80890   if (!jarg3) {
80891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80892     return ;
80893   }
80894   std::string arg3_str(jarg3);
80895   arg3 = &arg3_str;
80896   if (!jarg4) {
80897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80898     return ;
80899   }
80900   std::string arg4_str(jarg4);
80901   arg4 = &arg4_str;
80902   {
80903     try {
80904       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
80905     } catch (std::out_of_range& e) {
80906       {
80907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80908       };
80909     } catch (std::exception& e) {
80910       {
80911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80912       };
80913     } catch (Dali::DaliException e) {
80914       {
80915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80916       };
80917     } catch (...) {
80918       {
80919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80920       };
80921     }
80922   }
80923
80924
80925   //argout typemap for const std::string&
80926
80927
80928   //argout typemap for const std::string&
80929
80930 }
80931
80932
80933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
80934   void * jresult ;
80935   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80936   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
80937
80938   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80939   {
80940     try {
80941       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
80942     } catch (std::out_of_range& e) {
80943       {
80944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80945       };
80946     } catch (std::exception& e) {
80947       {
80948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80949       };
80950     } catch (Dali::DaliException e) {
80951       {
80952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80953       };
80954     } catch (...) {
80955       {
80956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80957       };
80958     }
80959   }
80960
80961   jresult = (void *)result;
80962   return jresult;
80963 }
80964
80965
80966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
80967   int jresult ;
80968   int result;
80969
80970   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
80971   jresult = (int)result;
80972   return jresult;
80973 }
80974
80975
80976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
80977   int jresult ;
80978   int result;
80979
80980   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
80981   jresult = (int)result;
80982   return jresult;
80983 }
80984
80985
80986 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
80987   int jresult ;
80988   int result;
80989
80990   result = (int)Dali::Toolkit::Slider::Property::VALUE;
80991   jresult = (int)result;
80992   return jresult;
80993 }
80994
80995
80996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
80997   int jresult ;
80998   int result;
80999
81000   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81001   jresult = (int)result;
81002   return jresult;
81003 }
81004
81005
81006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81007   int jresult ;
81008   int result;
81009
81010   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81011   jresult = (int)result;
81012   return jresult;
81013 }
81014
81015
81016 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81017   int jresult ;
81018   int result;
81019
81020   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81021   jresult = (int)result;
81022   return jresult;
81023 }
81024
81025
81026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81027   int jresult ;
81028   int result;
81029
81030   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81031   jresult = (int)result;
81032   return jresult;
81033 }
81034
81035
81036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81037   int jresult ;
81038   int result;
81039
81040   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81041   jresult = (int)result;
81042   return jresult;
81043 }
81044
81045
81046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81047   int jresult ;
81048   int result;
81049
81050   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81051   jresult = (int)result;
81052   return jresult;
81053 }
81054
81055
81056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81057   int jresult ;
81058   int result;
81059
81060   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81061   jresult = (int)result;
81062   return jresult;
81063 }
81064
81065
81066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81067   int jresult ;
81068   int result;
81069
81070   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81071   jresult = (int)result;
81072   return jresult;
81073 }
81074
81075
81076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81077   int jresult ;
81078   int result;
81079
81080   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81081   jresult = (int)result;
81082   return jresult;
81083 }
81084
81085
81086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81087   int jresult ;
81088   int result;
81089
81090   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81091   jresult = (int)result;
81092   return jresult;
81093 }
81094
81095
81096 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81097   int jresult ;
81098   int result;
81099
81100   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81101   jresult = (int)result;
81102   return jresult;
81103 }
81104
81105
81106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81107   int jresult ;
81108   int result;
81109
81110   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81111   jresult = (int)result;
81112   return jresult;
81113 }
81114
81115
81116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81117   void * jresult ;
81118   Dali::Toolkit::Slider::Property *result = 0 ;
81119
81120   {
81121     try {
81122       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81123     } catch (std::out_of_range& e) {
81124       {
81125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81126       };
81127     } catch (std::exception& e) {
81128       {
81129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81130       };
81131     } catch (Dali::DaliException e) {
81132       {
81133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81134       };
81135     } catch (...) {
81136       {
81137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81138       };
81139     }
81140   }
81141
81142   jresult = (void *)result;
81143   return jresult;
81144 }
81145
81146
81147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81148   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81149
81150   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81151   {
81152     try {
81153       delete arg1;
81154     } catch (std::out_of_range& e) {
81155       {
81156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81157       };
81158     } catch (std::exception& e) {
81159       {
81160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81161       };
81162     } catch (Dali::DaliException e) {
81163       {
81164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81165       };
81166     } catch (...) {
81167       {
81168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81169       };
81170     }
81171   }
81172
81173 }
81174
81175
81176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81177   void * jresult ;
81178   Dali::Toolkit::Slider result;
81179
81180   {
81181     try {
81182       result = Dali::Toolkit::Slider::New();
81183     } catch (std::out_of_range& e) {
81184       {
81185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81186       };
81187     } catch (std::exception& e) {
81188       {
81189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81190       };
81191     } catch (Dali::DaliException e) {
81192       {
81193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81194       };
81195     } catch (...) {
81196       {
81197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81198       };
81199     }
81200   }
81201
81202   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81203   return jresult;
81204 }
81205
81206
81207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81208   void * jresult ;
81209   Dali::Toolkit::Slider *result = 0 ;
81210
81211   {
81212     try {
81213       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81214     } catch (std::out_of_range& e) {
81215       {
81216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81217       };
81218     } catch (std::exception& e) {
81219       {
81220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81221       };
81222     } catch (Dali::DaliException e) {
81223       {
81224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81225       };
81226     } catch (...) {
81227       {
81228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81229       };
81230     }
81231   }
81232
81233   jresult = (void *)result;
81234   return jresult;
81235 }
81236
81237
81238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
81239   void * jresult ;
81240   Dali::Toolkit::Slider *arg1 = 0 ;
81241   Dali::Toolkit::Slider *result = 0 ;
81242
81243   arg1 = (Dali::Toolkit::Slider *)jarg1;
81244   if (!arg1) {
81245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81246     return 0;
81247   }
81248   {
81249     try {
81250       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81251     } catch (std::out_of_range& e) {
81252       {
81253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81254       };
81255     } catch (std::exception& e) {
81256       {
81257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81258       };
81259     } catch (Dali::DaliException e) {
81260       {
81261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81262       };
81263     } catch (...) {
81264       {
81265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81266       };
81267     }
81268   }
81269
81270   jresult = (void *)result;
81271   return jresult;
81272 }
81273
81274
81275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
81276   void * jresult ;
81277   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81278   Dali::Toolkit::Slider *arg2 = 0 ;
81279   Dali::Toolkit::Slider *result = 0 ;
81280
81281   arg1 = (Dali::Toolkit::Slider *)jarg1;
81282   arg2 = (Dali::Toolkit::Slider *)jarg2;
81283   if (!arg2) {
81284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81285     return 0;
81286   }
81287   {
81288     try {
81289       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81290     } catch (std::out_of_range& e) {
81291       {
81292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81293       };
81294     } catch (std::exception& e) {
81295       {
81296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81297       };
81298     } catch (Dali::DaliException e) {
81299       {
81300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81301       };
81302     } catch (...) {
81303       {
81304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81305       };
81306     }
81307   }
81308
81309   jresult = (void *)result;
81310   return jresult;
81311 }
81312
81313
81314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
81315   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81316
81317   arg1 = (Dali::Toolkit::Slider *)jarg1;
81318   {
81319     try {
81320       delete arg1;
81321     } catch (std::out_of_range& e) {
81322       {
81323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81324       };
81325     } catch (std::exception& e) {
81326       {
81327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81328       };
81329     } catch (Dali::DaliException e) {
81330       {
81331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81332       };
81333     } catch (...) {
81334       {
81335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81336       };
81337     }
81338   }
81339
81340 }
81341
81342
81343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
81344   void * jresult ;
81345   Dali::BaseHandle arg1 ;
81346   Dali::BaseHandle *argp1 ;
81347   Dali::Toolkit::Slider result;
81348
81349   argp1 = (Dali::BaseHandle *)jarg1;
81350   if (!argp1) {
81351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81352     return 0;
81353   }
81354   arg1 = *argp1;
81355   {
81356     try {
81357       result = Dali::Toolkit::Slider::DownCast(arg1);
81358     } catch (std::out_of_range& e) {
81359       {
81360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81361       };
81362     } catch (std::exception& e) {
81363       {
81364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81365       };
81366     } catch (Dali::DaliException e) {
81367       {
81368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81369       };
81370     } catch (...) {
81371       {
81372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81373       };
81374     }
81375   }
81376
81377   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81378   return jresult;
81379 }
81380
81381
81382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
81383   void * jresult ;
81384   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81385   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81386
81387   arg1 = (Dali::Toolkit::Slider *)jarg1;
81388   {
81389     try {
81390       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
81391     } catch (std::out_of_range& e) {
81392       {
81393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81394       };
81395     } catch (std::exception& e) {
81396       {
81397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81398       };
81399     } catch (Dali::DaliException e) {
81400       {
81401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81402       };
81403     } catch (...) {
81404       {
81405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81406       };
81407     }
81408   }
81409
81410   jresult = (void *)result;
81411   return jresult;
81412 }
81413
81414
81415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
81416   void * jresult ;
81417   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81418   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81419
81420   arg1 = (Dali::Toolkit::Slider *)jarg1;
81421   {
81422     try {
81423       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
81424     } catch (std::out_of_range& e) {
81425       {
81426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81427       };
81428     } catch (std::exception& e) {
81429       {
81430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81431       };
81432     } catch (Dali::DaliException e) {
81433       {
81434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81435       };
81436     } catch (...) {
81437       {
81438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81439       };
81440     }
81441   }
81442
81443   jresult = (void *)result;
81444   return jresult;
81445 }
81446
81447
81448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
81449   void * jresult ;
81450   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81451   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
81452
81453   arg1 = (Dali::Toolkit::Slider *)jarg1;
81454   {
81455     try {
81456       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
81457     } catch (std::out_of_range& e) {
81458       {
81459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81460       };
81461     } catch (std::exception& e) {
81462       {
81463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81464       };
81465     } catch (Dali::DaliException e) {
81466       {
81467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81468       };
81469     } catch (...) {
81470       {
81471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81472       };
81473     }
81474   }
81475
81476   jresult = (void *)result;
81477   return jresult;
81478 }
81479
81480
81481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
81482   int jresult ;
81483   int result;
81484
81485   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81486   jresult = (int)result;
81487   return jresult;
81488 }
81489
81490
81491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
81492   int jresult ;
81493   int result;
81494
81495   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81496   jresult = (int)result;
81497   return jresult;
81498 }
81499
81500
81501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
81502   int jresult ;
81503   int result;
81504
81505   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81506   jresult = (int)result;
81507   return jresult;
81508 }
81509
81510
81511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
81512   int jresult ;
81513   int result;
81514
81515   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81516   jresult = (int)result;
81517   return jresult;
81518 }
81519
81520
81521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
81522   int result;
81523
81524   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
81525
81526   return result;
81527 }
81528
81529
81530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
81531   void * jresult ;
81532   Dali::Toolkit::VideoView::Property *result = 0 ;
81533
81534   {
81535     try {
81536       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::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_VideoView_Property(void * jarg1) {
81562   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81563
81564   arg1 = (Dali::Toolkit::VideoView::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_VideoView_New__SWIG_0() {
81591   void * jresult ;
81592   Dali::Toolkit::VideoView result;
81593
81594   {
81595     try {
81596       result = Dali::Toolkit::VideoView::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::VideoView((const Dali::Toolkit::VideoView &)result);
81617   return jresult;
81618 }
81619
81620
81621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
81622   void * jresult ;
81623   std::string *arg1 = 0 ;
81624   Dali::Toolkit::VideoView result;
81625
81626   if (!jarg1) {
81627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81628     return 0;
81629   }
81630   std::string arg1_str(jarg1);
81631   arg1 = &arg1_str;
81632   {
81633     try {
81634       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81635     } catch (std::out_of_range& e) {
81636       {
81637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81638       };
81639     } catch (std::exception& e) {
81640       {
81641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81642       };
81643     } catch (Dali::DaliException e) {
81644       {
81645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81646       };
81647     } catch (...) {
81648       {
81649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81650       };
81651     }
81652   }
81653
81654   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81655
81656   //argout typemap for const std::string&
81657
81658   return jresult;
81659 }
81660
81661
81662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
81663   void * jresult ;
81664   Dali::Toolkit::VideoView result;
81665   {
81666     try {
81667       result = Dali::Toolkit::VideoView::New(swCodec);
81668     } catch (std::out_of_range& e) {
81669       {
81670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81671       };
81672     } catch (std::exception& e) {
81673       {
81674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81675       };
81676     } catch (Dali::DaliException e) {
81677       {
81678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81679       };
81680     } catch (...) {
81681       {
81682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81683       };
81684     }
81685   }
81686
81687   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81688
81689   //argout typemap for const std::string&
81690
81691   return jresult;
81692 }
81693
81694
81695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
81696   void * jresult ;
81697   std::string *arg1 = 0 ;
81698   Dali::Toolkit::VideoView result;
81699
81700   if (!jarg1) {
81701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81702     return 0;
81703   }
81704   std::string arg1_str(jarg1);
81705   arg1 = &arg1_str;
81706   {
81707     try {
81708       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
81709     } catch (std::out_of_range& e) {
81710       {
81711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81712       };
81713     } catch (std::exception& e) {
81714       {
81715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81716       };
81717     } catch (Dali::DaliException e) {
81718       {
81719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81720       };
81721     } catch (...) {
81722       {
81723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81724       };
81725     }
81726   }
81727
81728   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81729
81730   //argout typemap for const std::string&
81731
81732   return jresult;
81733 }
81734
81735
81736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
81737   void * jresult ;
81738   Dali::Toolkit::VideoView *result = 0 ;
81739
81740   {
81741     try {
81742       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
81743     } catch (std::out_of_range& e) {
81744       {
81745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81746       };
81747     } catch (std::exception& e) {
81748       {
81749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81750       };
81751     } catch (Dali::DaliException e) {
81752       {
81753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81754       };
81755     } catch (...) {
81756       {
81757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81758       };
81759     }
81760   }
81761
81762   jresult = (void *)result;
81763   return jresult;
81764 }
81765
81766
81767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
81768   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81769
81770   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81771   {
81772     try {
81773       delete arg1;
81774     } catch (std::out_of_range& e) {
81775       {
81776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81777       };
81778     } catch (std::exception& e) {
81779       {
81780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81781       };
81782     } catch (Dali::DaliException e) {
81783       {
81784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81785       };
81786     } catch (...) {
81787       {
81788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81789       };
81790     }
81791   }
81792
81793 }
81794
81795
81796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
81797   void * jresult ;
81798   Dali::Toolkit::VideoView *arg1 = 0 ;
81799   Dali::Toolkit::VideoView *result = 0 ;
81800
81801   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81802   if (!arg1) {
81803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81804     return 0;
81805   }
81806   {
81807     try {
81808       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
81809     } catch (std::out_of_range& e) {
81810       {
81811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81812       };
81813     } catch (std::exception& e) {
81814       {
81815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81816       };
81817     } catch (Dali::DaliException e) {
81818       {
81819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81820       };
81821     } catch (...) {
81822       {
81823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81824       };
81825     }
81826   }
81827
81828   jresult = (void *)result;
81829   return jresult;
81830 }
81831
81832
81833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
81834   void * jresult ;
81835   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81836   Dali::Toolkit::VideoView *arg2 = 0 ;
81837   Dali::Toolkit::VideoView *result = 0 ;
81838
81839   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81840   arg2 = (Dali::Toolkit::VideoView *)jarg2;
81841   if (!arg2) {
81842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81843     return 0;
81844   }
81845   {
81846     try {
81847       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
81848     } catch (std::out_of_range& e) {
81849       {
81850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81851       };
81852     } catch (std::exception& e) {
81853       {
81854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81855       };
81856     } catch (Dali::DaliException e) {
81857       {
81858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81859       };
81860     } catch (...) {
81861       {
81862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81863       };
81864     }
81865   }
81866
81867   jresult = (void *)result;
81868   return jresult;
81869 }
81870
81871
81872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
81873   void * jresult ;
81874   Dali::BaseHandle arg1 ;
81875   Dali::BaseHandle *argp1 ;
81876   Dali::Toolkit::VideoView result;
81877
81878   argp1 = (Dali::BaseHandle *)jarg1;
81879   if (!argp1) {
81880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81881     return 0;
81882   }
81883   arg1 = *argp1;
81884   {
81885     try {
81886       result = Dali::Toolkit::VideoView::DownCast(arg1);
81887     } catch (std::out_of_range& e) {
81888       {
81889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81890       };
81891     } catch (std::exception& e) {
81892       {
81893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81894       };
81895     } catch (Dali::DaliException e) {
81896       {
81897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81898       };
81899     } catch (...) {
81900       {
81901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81902       };
81903     }
81904   }
81905
81906   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81907   return jresult;
81908 }
81909
81910
81911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
81912   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81913
81914   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81915   {
81916     try {
81917       (arg1)->Play();
81918     } catch (std::out_of_range& e) {
81919       {
81920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81921       };
81922     } catch (std::exception& e) {
81923       {
81924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81925       };
81926     } catch (Dali::DaliException e) {
81927       {
81928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81929       };
81930     } catch (...) {
81931       {
81932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81933       };
81934     }
81935   }
81936
81937 }
81938
81939
81940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
81941   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81942
81943   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81944   {
81945     try {
81946       (arg1)->Pause();
81947     } catch (std::out_of_range& e) {
81948       {
81949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81950       };
81951     } catch (std::exception& e) {
81952       {
81953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81954       };
81955     } catch (Dali::DaliException e) {
81956       {
81957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81958       };
81959     } catch (...) {
81960       {
81961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81962       };
81963     }
81964   }
81965
81966 }
81967
81968
81969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
81970   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81971
81972   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81973   {
81974     try {
81975       (arg1)->Stop();
81976     } catch (std::out_of_range& e) {
81977       {
81978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81979       };
81980     } catch (std::exception& e) {
81981       {
81982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81983       };
81984     } catch (Dali::DaliException e) {
81985       {
81986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81987       };
81988     } catch (...) {
81989       {
81990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81991       };
81992     }
81993   }
81994
81995 }
81996
81997
81998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
81999   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82000   int arg2 ;
82001
82002   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82003   arg2 = (int)jarg2;
82004   {
82005     try {
82006       (arg1)->Forward(arg2);
82007     } catch (std::out_of_range& e) {
82008       {
82009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82010       };
82011     } catch (std::exception& e) {
82012       {
82013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82014       };
82015     } catch (Dali::DaliException e) {
82016       {
82017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82018       };
82019     } catch (...) {
82020       {
82021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82022       };
82023     }
82024   }
82025
82026 }
82027
82028
82029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82030   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82031   int arg2 ;
82032
82033   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82034   arg2 = (int)jarg2;
82035   {
82036     try {
82037       (arg1)->Backward(arg2);
82038     } catch (std::out_of_range& e) {
82039       {
82040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82041       };
82042     } catch (std::exception& e) {
82043       {
82044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82045       };
82046     } catch (Dali::DaliException e) {
82047       {
82048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82049       };
82050     } catch (...) {
82051       {
82052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82053       };
82054     }
82055   }
82056
82057 }
82058
82059
82060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82061   void * jresult ;
82062   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82063   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82064
82065   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82066   {
82067     try {
82068       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82069     } catch (std::out_of_range& e) {
82070       {
82071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82072       };
82073     } catch (std::exception& e) {
82074       {
82075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82076       };
82077     } catch (Dali::DaliException e) {
82078       {
82079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82080       };
82081     } catch (...) {
82082       {
82083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82084       };
82085     }
82086   }
82087
82088   jresult = (void *)result;
82089   return jresult;
82090 }
82091
82092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
82093 {
82094   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
82095   if( arg1 == nullptr )
82096   {
82097     DALI_LOG_ERROR("VideoView is nullptr!");
82098     return nullptr;
82099   }
82100   void * ret = nullptr;
82101   {
82102     try{
82103
82104       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
82105       ret = Dali::AnyCast< void * >( result );
82106
82107     } catch (std::out_of_range& e) {
82108       {
82109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82110       };
82111     } catch (std::exception& e) {
82112       {
82113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82114       };
82115     } catch (Dali::DaliException e) {
82116       {
82117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82118       };
82119     } catch (...) {
82120       {
82121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82122       };
82123     }
82124   }
82125   return ret;
82126 }
82127
82128
82129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82130   int jresult ;
82131   int result;
82132
82133   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82134   jresult = (int)result;
82135   return jresult;
82136 }
82137
82138
82139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82140   int jresult ;
82141   int result;
82142
82143   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82144   jresult = (int)result;
82145   return jresult;
82146 }
82147
82148
82149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82150   int jresult ;
82151   int result;
82152
82153   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82154   jresult = (int)result;
82155   return jresult;
82156 }
82157
82158
82159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82160   int jresult ;
82161   int result;
82162
82163   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82164   jresult = (int)result;
82165   return jresult;
82166 }
82167
82168
82169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82170   int jresult ;
82171   int result;
82172
82173   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82174   jresult = (int)result;
82175   return jresult;
82176 }
82177
82178
82179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82180   int jresult ;
82181   int result;
82182
82183   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82184   jresult = (int)result;
82185   return jresult;
82186 }
82187
82188
82189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82190   int jresult ;
82191   int result;
82192
82193   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82194   jresult = (int)result;
82195   return jresult;
82196 }
82197
82198
82199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82200   int jresult ;
82201   int result;
82202
82203   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82204   jresult = (int)result;
82205   return jresult;
82206 }
82207
82208
82209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82210   int jresult ;
82211   int result;
82212
82213   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82214   jresult = (int)result;
82215   return jresult;
82216 }
82217
82218
82219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82220   int jresult ;
82221   int result;
82222
82223   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82224   jresult = (int)result;
82225   return jresult;
82226 }
82227
82228
82229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82230   int jresult ;
82231   int result;
82232
82233   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82234   jresult = (int)result;
82235   return jresult;
82236 }
82237
82238
82239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82240   int jresult ;
82241   int result;
82242
82243   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82244   jresult = (int)result;
82245   return jresult;
82246 }
82247
82248
82249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82250   int jresult ;
82251   int result;
82252
82253   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82254   jresult = (int)result;
82255   return jresult;
82256 }
82257
82258
82259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82260   int jresult ;
82261   int result;
82262
82263   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82264   jresult = (int)result;
82265   return jresult;
82266 }
82267
82268
82269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82270   int jresult ;
82271   int result;
82272
82273   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82274   jresult = (int)result;
82275   return jresult;
82276 }
82277
82278
82279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82280   int jresult ;
82281   int result;
82282
82283   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82284   jresult = (int)result;
82285   return jresult;
82286 }
82287
82288
82289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82290   int jresult ;
82291   int result;
82292
82293   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82294   jresult = (int)result;
82295   return jresult;
82296 }
82297
82298
82299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82300   int jresult ;
82301   int result;
82302
82303   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82304   jresult = (int)result;
82305   return jresult;
82306 }
82307
82308
82309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82310   int jresult ;
82311   int result;
82312
82313   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82314   jresult = (int)result;
82315   return jresult;
82316 }
82317
82318
82319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82320   int jresult ;
82321   int result;
82322
82323   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82324   jresult = (int)result;
82325   return jresult;
82326 }
82327
82328
82329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82330   int jresult ;
82331   int result;
82332
82333   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82334   jresult = (int)result;
82335   return jresult;
82336 }
82337
82338
82339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82340   void * jresult ;
82341   Dali::Toolkit::Popup::Property *result = 0 ;
82342
82343   {
82344     try {
82345       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82346     } catch (std::out_of_range& e) {
82347       {
82348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82349       };
82350     } catch (std::exception& e) {
82351       {
82352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82353       };
82354     } catch (Dali::DaliException e) {
82355       {
82356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82357       };
82358     } catch (...) {
82359       {
82360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82361       };
82362     }
82363   }
82364
82365   jresult = (void *)result;
82366   return jresult;
82367 }
82368
82369
82370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82371   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82372
82373   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82374   {
82375     try {
82376       delete arg1;
82377     } catch (std::out_of_range& e) {
82378       {
82379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82380       };
82381     } catch (std::exception& e) {
82382       {
82383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82384       };
82385     } catch (Dali::DaliException e) {
82386       {
82387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82388       };
82389     } catch (...) {
82390       {
82391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82392       };
82393     }
82394   }
82395
82396 }
82397
82398
82399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82400   void * jresult ;
82401   Dali::Toolkit::Popup *result = 0 ;
82402
82403   {
82404     try {
82405       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82406     } catch (std::out_of_range& e) {
82407       {
82408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82409       };
82410     } catch (std::exception& e) {
82411       {
82412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82413       };
82414     } catch (Dali::DaliException e) {
82415       {
82416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82417       };
82418     } catch (...) {
82419       {
82420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82421       };
82422     }
82423   }
82424
82425   jresult = (void *)result;
82426   return jresult;
82427 }
82428
82429
82430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82431   void * jresult ;
82432   Dali::Toolkit::Popup result;
82433
82434   {
82435     try {
82436       result = Dali::Toolkit::Popup::New();
82437     } catch (std::out_of_range& e) {
82438       {
82439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82440       };
82441     } catch (std::exception& e) {
82442       {
82443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82444       };
82445     } catch (Dali::DaliException e) {
82446       {
82447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82448       };
82449     } catch (...) {
82450       {
82451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82452       };
82453     }
82454   }
82455
82456   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82457   return jresult;
82458 }
82459
82460
82461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82462   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82463
82464   arg1 = (Dali::Toolkit::Popup *)jarg1;
82465   {
82466     try {
82467       delete arg1;
82468     } catch (std::out_of_range& e) {
82469       {
82470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82471       };
82472     } catch (std::exception& e) {
82473       {
82474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82475       };
82476     } catch (Dali::DaliException e) {
82477       {
82478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82479       };
82480     } catch (...) {
82481       {
82482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82483       };
82484     }
82485   }
82486
82487 }
82488
82489
82490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
82491   void * jresult ;
82492   Dali::Toolkit::Popup *arg1 = 0 ;
82493   Dali::Toolkit::Popup *result = 0 ;
82494
82495   arg1 = (Dali::Toolkit::Popup *)jarg1;
82496   if (!arg1) {
82497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82498     return 0;
82499   }
82500   {
82501     try {
82502       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
82503     } catch (std::out_of_range& e) {
82504       {
82505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82506       };
82507     } catch (std::exception& e) {
82508       {
82509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82510       };
82511     } catch (Dali::DaliException e) {
82512       {
82513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82514       };
82515     } catch (...) {
82516       {
82517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82518       };
82519     }
82520   }
82521
82522   jresult = (void *)result;
82523   return jresult;
82524 }
82525
82526
82527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
82528   void * jresult ;
82529   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82530   Dali::Toolkit::Popup *arg2 = 0 ;
82531   Dali::Toolkit::Popup *result = 0 ;
82532
82533   arg1 = (Dali::Toolkit::Popup *)jarg1;
82534   arg2 = (Dali::Toolkit::Popup *)jarg2;
82535   if (!arg2) {
82536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82537     return 0;
82538   }
82539   {
82540     try {
82541       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
82542     } catch (std::out_of_range& e) {
82543       {
82544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82545       };
82546     } catch (std::exception& e) {
82547       {
82548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82549       };
82550     } catch (Dali::DaliException e) {
82551       {
82552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82553       };
82554     } catch (...) {
82555       {
82556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82557       };
82558     }
82559   }
82560
82561   jresult = (void *)result;
82562   return jresult;
82563 }
82564
82565
82566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
82567   void * jresult ;
82568   Dali::BaseHandle arg1 ;
82569   Dali::BaseHandle *argp1 ;
82570   Dali::Toolkit::Popup result;
82571
82572   argp1 = (Dali::BaseHandle *)jarg1;
82573   if (!argp1) {
82574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82575     return 0;
82576   }
82577   arg1 = *argp1;
82578   {
82579     try {
82580       result = Dali::Toolkit::Popup::DownCast(arg1);
82581     } catch (std::out_of_range& e) {
82582       {
82583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82584       };
82585     } catch (std::exception& e) {
82586       {
82587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82588       };
82589     } catch (Dali::DaliException e) {
82590       {
82591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82592       };
82593     } catch (...) {
82594       {
82595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82596       };
82597     }
82598   }
82599
82600   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82601   return jresult;
82602 }
82603
82604
82605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
82606   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82607   Dali::Actor arg2 ;
82608   Dali::Actor *argp2 ;
82609
82610   arg1 = (Dali::Toolkit::Popup *)jarg1;
82611   argp2 = (Dali::Actor *)jarg2;
82612   if (!argp2) {
82613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82614     return ;
82615   }
82616   arg2 = *argp2;
82617   {
82618     try {
82619       (arg1)->SetTitle(arg2);
82620     } catch (std::out_of_range& e) {
82621       {
82622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82623       };
82624     } catch (std::exception& e) {
82625       {
82626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82627       };
82628     } catch (Dali::DaliException e) {
82629       {
82630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82631       };
82632     } catch (...) {
82633       {
82634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82635       };
82636     }
82637   }
82638
82639 }
82640
82641
82642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
82643   void * jresult ;
82644   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82645   Dali::Actor result;
82646
82647   arg1 = (Dali::Toolkit::Popup *)jarg1;
82648   {
82649     try {
82650       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
82651     } catch (std::out_of_range& e) {
82652       {
82653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82654       };
82655     } catch (std::exception& e) {
82656       {
82657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82658       };
82659     } catch (Dali::DaliException e) {
82660       {
82661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82662       };
82663     } catch (...) {
82664       {
82665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82666       };
82667     }
82668   }
82669
82670   jresult = new Dali::Actor((const Dali::Actor &)result);
82671   return jresult;
82672 }
82673
82674
82675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
82676   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82677   Dali::Actor arg2 ;
82678   Dali::Actor *argp2 ;
82679
82680   arg1 = (Dali::Toolkit::Popup *)jarg1;
82681   argp2 = (Dali::Actor *)jarg2;
82682   if (!argp2) {
82683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82684     return ;
82685   }
82686   arg2 = *argp2;
82687   {
82688     try {
82689       (arg1)->SetContent(arg2);
82690     } catch (std::out_of_range& e) {
82691       {
82692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82693       };
82694     } catch (std::exception& e) {
82695       {
82696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82697       };
82698     } catch (Dali::DaliException e) {
82699       {
82700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82701       };
82702     } catch (...) {
82703       {
82704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82705       };
82706     }
82707   }
82708
82709 }
82710
82711
82712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
82713   void * jresult ;
82714   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82715   Dali::Actor result;
82716
82717   arg1 = (Dali::Toolkit::Popup *)jarg1;
82718   {
82719     try {
82720       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
82721     } catch (std::out_of_range& e) {
82722       {
82723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82724       };
82725     } catch (std::exception& e) {
82726       {
82727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82728       };
82729     } catch (Dali::DaliException e) {
82730       {
82731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82732       };
82733     } catch (...) {
82734       {
82735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82736       };
82737     }
82738   }
82739
82740   jresult = new Dali::Actor((const Dali::Actor &)result);
82741   return jresult;
82742 }
82743
82744
82745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
82746   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82747   Dali::Actor arg2 ;
82748   Dali::Actor *argp2 ;
82749
82750   arg1 = (Dali::Toolkit::Popup *)jarg1;
82751   argp2 = (Dali::Actor *)jarg2;
82752   if (!argp2) {
82753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82754     return ;
82755   }
82756   arg2 = *argp2;
82757   {
82758     try {
82759       (arg1)->SetFooter(arg2);
82760     } catch (std::out_of_range& e) {
82761       {
82762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82763       };
82764     } catch (std::exception& e) {
82765       {
82766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82767       };
82768     } catch (Dali::DaliException e) {
82769       {
82770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82771       };
82772     } catch (...) {
82773       {
82774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82775       };
82776     }
82777   }
82778
82779 }
82780
82781
82782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
82783   void * jresult ;
82784   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82785   Dali::Actor result;
82786
82787   arg1 = (Dali::Toolkit::Popup *)jarg1;
82788   {
82789     try {
82790       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
82791     } catch (std::out_of_range& e) {
82792       {
82793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82794       };
82795     } catch (std::exception& e) {
82796       {
82797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82798       };
82799     } catch (Dali::DaliException e) {
82800       {
82801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82802       };
82803     } catch (...) {
82804       {
82805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82806       };
82807     }
82808   }
82809
82810   jresult = new Dali::Actor((const Dali::Actor &)result);
82811   return jresult;
82812 }
82813
82814
82815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
82816   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82817   Dali::Toolkit::Popup::DisplayState arg2 ;
82818
82819   arg1 = (Dali::Toolkit::Popup *)jarg1;
82820   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
82821   {
82822     try {
82823       (arg1)->SetDisplayState(arg2);
82824     } catch (std::out_of_range& e) {
82825       {
82826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82827       };
82828     } catch (std::exception& e) {
82829       {
82830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82831       };
82832     } catch (Dali::DaliException e) {
82833       {
82834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82835       };
82836     } catch (...) {
82837       {
82838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82839       };
82840     }
82841   }
82842
82843 }
82844
82845
82846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
82847   int jresult ;
82848   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82849   Dali::Toolkit::Popup::DisplayState result;
82850
82851   arg1 = (Dali::Toolkit::Popup *)jarg1;
82852   {
82853     try {
82854       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
82855     } catch (std::out_of_range& e) {
82856       {
82857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82858       };
82859     } catch (std::exception& e) {
82860       {
82861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82862       };
82863     } catch (Dali::DaliException e) {
82864       {
82865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82866       };
82867     } catch (...) {
82868       {
82869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82870       };
82871     }
82872   }
82873
82874   jresult = (int)result;
82875   return jresult;
82876 }
82877
82878
82879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
82880   void * jresult ;
82881   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82882   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
82883
82884   arg1 = (Dali::Toolkit::Popup *)jarg1;
82885   {
82886     try {
82887       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
82888     } catch (std::out_of_range& e) {
82889       {
82890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82891       };
82892     } catch (std::exception& e) {
82893       {
82894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82895       };
82896     } catch (Dali::DaliException e) {
82897       {
82898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82899       };
82900     } catch (...) {
82901       {
82902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82903       };
82904     }
82905   }
82906
82907   jresult = (void *)result;
82908   return jresult;
82909 }
82910
82911
82912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
82913   void * jresult ;
82914   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82915   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82916
82917   arg1 = (Dali::Toolkit::Popup *)jarg1;
82918   {
82919     try {
82920       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
82921     } catch (std::out_of_range& e) {
82922       {
82923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82924       };
82925     } catch (std::exception& e) {
82926       {
82927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82928       };
82929     } catch (Dali::DaliException e) {
82930       {
82931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82932       };
82933     } catch (...) {
82934       {
82935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82936       };
82937     }
82938   }
82939
82940   jresult = (void *)result;
82941   return jresult;
82942 }
82943
82944
82945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
82946   void * jresult ;
82947   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82948   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82949
82950   arg1 = (Dali::Toolkit::Popup *)jarg1;
82951   {
82952     try {
82953       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
82954     } catch (std::out_of_range& e) {
82955       {
82956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82957       };
82958     } catch (std::exception& e) {
82959       {
82960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82961       };
82962     } catch (Dali::DaliException e) {
82963       {
82964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82965       };
82966     } catch (...) {
82967       {
82968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82969       };
82970     }
82971   }
82972
82973   jresult = (void *)result;
82974   return jresult;
82975 }
82976
82977
82978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
82979   void * jresult ;
82980   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82981   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
82982
82983   arg1 = (Dali::Toolkit::Popup *)jarg1;
82984   {
82985     try {
82986       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
82987     } catch (std::out_of_range& e) {
82988       {
82989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82990       };
82991     } catch (std::exception& e) {
82992       {
82993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82994       };
82995     } catch (Dali::DaliException e) {
82996       {
82997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82998       };
82999     } catch (...) {
83000       {
83001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83002       };
83003     }
83004   }
83005
83006   jresult = (void *)result;
83007   return jresult;
83008 }
83009
83010
83011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83012   void * jresult ;
83013   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83014   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83015
83016   arg1 = (Dali::Toolkit::Popup *)jarg1;
83017   {
83018     try {
83019       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83020     } catch (std::out_of_range& e) {
83021       {
83022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83023       };
83024     } catch (std::exception& e) {
83025       {
83026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83027       };
83028     } catch (Dali::DaliException e) {
83029       {
83030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83031       };
83032     } catch (...) {
83033       {
83034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83035       };
83036     }
83037   }
83038
83039   jresult = (void *)result;
83040   return jresult;
83041 }
83042
83043
83044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83045   int jresult ;
83046   int result;
83047
83048   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83049   jresult = (int)result;
83050   return jresult;
83051 }
83052
83053
83054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83055   int jresult ;
83056   int result;
83057
83058   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83059   jresult = (int)result;
83060   return jresult;
83061 }
83062
83063
83064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83065   int jresult ;
83066   int result;
83067
83068   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83069   jresult = (int)result;
83070   return jresult;
83071 }
83072
83073
83074 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83075   int jresult ;
83076   int result;
83077
83078   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83079   jresult = (int)result;
83080   return jresult;
83081 }
83082
83083
83084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83085   int jresult ;
83086   int result;
83087
83088   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83089   jresult = (int)result;
83090   return jresult;
83091 }
83092
83093
83094 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83095   int jresult ;
83096   int result;
83097
83098   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83099   jresult = (int)result;
83100   return jresult;
83101 }
83102
83103
83104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83105   int jresult ;
83106   int result;
83107
83108   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83109   jresult = (int)result;
83110   return jresult;
83111 }
83112
83113
83114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83115   int jresult ;
83116   int result;
83117
83118   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83119   jresult = (int)result;
83120   return jresult;
83121 }
83122
83123
83124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83125   int jresult ;
83126   int result;
83127
83128   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83129   jresult = (int)result;
83130   return jresult;
83131 }
83132
83133
83134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83135   void * jresult ;
83136   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83137
83138   {
83139     try {
83140       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83141     } catch (std::out_of_range& e) {
83142       {
83143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83144       };
83145     } catch (std::exception& e) {
83146       {
83147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83148       };
83149     } catch (Dali::DaliException e) {
83150       {
83151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83152       };
83153     } catch (...) {
83154       {
83155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83156       };
83157     }
83158   }
83159
83160   jresult = (void *)result;
83161   return jresult;
83162 }
83163
83164
83165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83166   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83167
83168   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83169   {
83170     try {
83171       delete arg1;
83172     } catch (std::out_of_range& e) {
83173       {
83174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83175       };
83176     } catch (std::exception& e) {
83177       {
83178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83179       };
83180     } catch (Dali::DaliException e) {
83181       {
83182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83183       };
83184     } catch (...) {
83185       {
83186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83187       };
83188     }
83189   }
83190
83191 }
83192
83193
83194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83195   void * jresult ;
83196   Dali::Toolkit::ProgressBar result;
83197
83198   {
83199     try {
83200       result = Dali::Toolkit::ProgressBar::New();
83201     } catch (std::out_of_range& e) {
83202       {
83203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83204       };
83205     } catch (std::exception& e) {
83206       {
83207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83208       };
83209     } catch (Dali::DaliException e) {
83210       {
83211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83212       };
83213     } catch (...) {
83214       {
83215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83216       };
83217     }
83218   }
83219
83220   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83221   return jresult;
83222 }
83223
83224
83225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83226   void * jresult ;
83227   Dali::Toolkit::ProgressBar *result = 0 ;
83228
83229   {
83230     try {
83231       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83232     } catch (std::out_of_range& e) {
83233       {
83234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83235       };
83236     } catch (std::exception& e) {
83237       {
83238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83239       };
83240     } catch (Dali::DaliException e) {
83241       {
83242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83243       };
83244     } catch (...) {
83245       {
83246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83247       };
83248     }
83249   }
83250
83251   jresult = (void *)result;
83252   return jresult;
83253 }
83254
83255
83256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83257   void * jresult ;
83258   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83259   Dali::Toolkit::ProgressBar *result = 0 ;
83260
83261   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83262   if (!arg1) {
83263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83264     return 0;
83265   }
83266   {
83267     try {
83268       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
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 = (void *)result;
83289   return jresult;
83290 }
83291
83292
83293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83294   void * jresult ;
83295   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83296   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83297   Dali::Toolkit::ProgressBar *result = 0 ;
83298
83299   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83300   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83301   if (!arg2) {
83302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83303     return 0;
83304   }
83305   {
83306     try {
83307       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83308     } catch (std::out_of_range& e) {
83309       {
83310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83311       };
83312     } catch (std::exception& e) {
83313       {
83314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83315       };
83316     } catch (Dali::DaliException e) {
83317       {
83318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83319       };
83320     } catch (...) {
83321       {
83322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83323       };
83324     }
83325   }
83326
83327   jresult = (void *)result;
83328   return jresult;
83329 }
83330
83331
83332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83333   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83334
83335   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83336   {
83337     try {
83338       delete arg1;
83339     } catch (std::out_of_range& e) {
83340       {
83341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83342       };
83343     } catch (std::exception& e) {
83344       {
83345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83346       };
83347     } catch (Dali::DaliException e) {
83348       {
83349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83350       };
83351     } catch (...) {
83352       {
83353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83354       };
83355     }
83356   }
83357
83358 }
83359
83360
83361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83362   void * jresult ;
83363   Dali::BaseHandle arg1 ;
83364   Dali::BaseHandle *argp1 ;
83365   Dali::Toolkit::ProgressBar result;
83366
83367   argp1 = (Dali::BaseHandle *)jarg1;
83368   if (!argp1) {
83369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83370     return 0;
83371   }
83372   arg1 = *argp1;
83373   {
83374     try {
83375       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83376     } catch (std::out_of_range& e) {
83377       {
83378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83379       };
83380     } catch (std::exception& e) {
83381       {
83382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83383       };
83384     } catch (Dali::DaliException e) {
83385       {
83386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83387       };
83388     } catch (...) {
83389       {
83390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83391       };
83392     }
83393   }
83394
83395   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83396   return jresult;
83397 }
83398
83399
83400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83401   void * jresult ;
83402   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83403   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83404
83405   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83406   {
83407     try {
83408       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83409     } catch (std::out_of_range& e) {
83410       {
83411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83412       };
83413     } catch (std::exception& e) {
83414       {
83415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83416       };
83417     } catch (Dali::DaliException e) {
83418       {
83419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83420       };
83421     } catch (...) {
83422       {
83423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83424       };
83425     }
83426   }
83427
83428   jresult = (void *)result;
83429   return jresult;
83430 }
83431
83432
83433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83434   void * jresult ;
83435   Dali::Toolkit::GaussianBlurView *result = 0 ;
83436
83437   {
83438     try {
83439       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83440     } catch (std::out_of_range& e) {
83441       {
83442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83443       };
83444     } catch (std::exception& e) {
83445       {
83446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83447       };
83448     } catch (Dali::DaliException e) {
83449       {
83450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83451       };
83452     } catch (...) {
83453       {
83454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83455       };
83456     }
83457   }
83458
83459   jresult = (void *)result;
83460   return jresult;
83461 }
83462
83463
83464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83465   void * jresult ;
83466   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83467   Dali::Toolkit::GaussianBlurView *result = 0 ;
83468
83469   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83470   if (!arg1) {
83471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83472     return 0;
83473   }
83474   {
83475     try {
83476       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83477     } catch (std::out_of_range& e) {
83478       {
83479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83480       };
83481     } catch (std::exception& e) {
83482       {
83483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83484       };
83485     } catch (Dali::DaliException e) {
83486       {
83487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83488       };
83489     } catch (...) {
83490       {
83491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83492       };
83493     }
83494   }
83495
83496   jresult = (void *)result;
83497   return jresult;
83498 }
83499
83500
83501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83502   void * jresult ;
83503   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83504   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83505   Dali::Toolkit::GaussianBlurView *result = 0 ;
83506
83507   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83508   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83509   if (!arg2) {
83510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83511     return 0;
83512   }
83513   {
83514     try {
83515       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
83516     } catch (std::out_of_range& e) {
83517       {
83518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83519       };
83520     } catch (std::exception& e) {
83521       {
83522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83523       };
83524     } catch (Dali::DaliException e) {
83525       {
83526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83527       };
83528     } catch (...) {
83529       {
83530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83531       };
83532     }
83533   }
83534
83535   jresult = (void *)result;
83536   return jresult;
83537 }
83538
83539
83540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
83541   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83542
83543   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83544   {
83545     try {
83546       delete arg1;
83547     } catch (std::out_of_range& e) {
83548       {
83549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83550       };
83551     } catch (std::exception& e) {
83552       {
83553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83554       };
83555     } catch (Dali::DaliException e) {
83556       {
83557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83558       };
83559     } catch (...) {
83560       {
83561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83562       };
83563     }
83564   }
83565
83566 }
83567
83568
83569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
83570   void * jresult ;
83571   Dali::BaseHandle arg1 ;
83572   Dali::BaseHandle *argp1 ;
83573   Dali::Toolkit::GaussianBlurView result;
83574
83575   argp1 = (Dali::BaseHandle *)jarg1;
83576   if (!argp1) {
83577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83578     return 0;
83579   }
83580   arg1 = *argp1;
83581   {
83582     try {
83583       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83584     } catch (std::out_of_range& e) {
83585       {
83586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83587       };
83588     } catch (std::exception& e) {
83589       {
83590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83591       };
83592     } catch (Dali::DaliException e) {
83593       {
83594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83595       };
83596     } catch (...) {
83597       {
83598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83599       };
83600     }
83601   }
83602
83603   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83604   return jresult;
83605 }
83606
83607
83608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
83609   void * jresult ;
83610   Dali::Toolkit::GaussianBlurView result;
83611
83612   {
83613     try {
83614       result = Dali::Toolkit::GaussianBlurView::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::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83635   return jresult;
83636 }
83637
83638
83639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
83640   void * jresult ;
83641   unsigned int arg1 ;
83642   float arg2 ;
83643   Dali::Pixel::Format arg3 ;
83644   float arg4 ;
83645   float arg5 ;
83646   bool arg6 ;
83647   Dali::Toolkit::GaussianBlurView result;
83648
83649   arg1 = (unsigned int)jarg1;
83650   arg2 = (float)jarg2;
83651   arg3 = (Dali::Pixel::Format)jarg3;
83652   arg4 = (float)jarg4;
83653   arg5 = (float)jarg5;
83654   arg6 = jarg6 ? true : false;
83655   {
83656     try {
83657       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
83658     } catch (std::out_of_range& e) {
83659       {
83660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83661       };
83662     } catch (std::exception& e) {
83663       {
83664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83665       };
83666     } catch (Dali::DaliException e) {
83667       {
83668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83669       };
83670     } catch (...) {
83671       {
83672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83673       };
83674     }
83675   }
83676
83677   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83678   return jresult;
83679 }
83680
83681
83682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
83683   void * jresult ;
83684   unsigned int arg1 ;
83685   float arg2 ;
83686   Dali::Pixel::Format arg3 ;
83687   float arg4 ;
83688   float arg5 ;
83689   Dali::Toolkit::GaussianBlurView result;
83690
83691   arg1 = (unsigned int)jarg1;
83692   arg2 = (float)jarg2;
83693   arg3 = (Dali::Pixel::Format)jarg3;
83694   arg4 = (float)jarg4;
83695   arg5 = (float)jarg5;
83696   {
83697     try {
83698       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
83699     } catch (std::out_of_range& e) {
83700       {
83701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83702       };
83703     } catch (std::exception& e) {
83704       {
83705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83706       };
83707     } catch (Dali::DaliException e) {
83708       {
83709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83710       };
83711     } catch (...) {
83712       {
83713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83714       };
83715     }
83716   }
83717
83718   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83719   return jresult;
83720 }
83721
83722
83723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
83724   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83725   Dali::Actor arg2 ;
83726   Dali::Actor *argp2 ;
83727
83728   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83729   argp2 = (Dali::Actor *)jarg2;
83730   if (!argp2) {
83731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83732     return ;
83733   }
83734   arg2 = *argp2;
83735   {
83736     try {
83737       (arg1)->Add(arg2);
83738     } catch (std::out_of_range& e) {
83739       {
83740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83741       };
83742     } catch (std::exception& e) {
83743       {
83744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83745       };
83746     } catch (Dali::DaliException e) {
83747       {
83748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83749       };
83750     } catch (...) {
83751       {
83752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83753       };
83754     }
83755   }
83756
83757 }
83758
83759
83760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
83761   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83762   Dali::Actor arg2 ;
83763   Dali::Actor *argp2 ;
83764
83765   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83766   argp2 = (Dali::Actor *)jarg2;
83767   if (!argp2) {
83768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83769     return ;
83770   }
83771   arg2 = *argp2;
83772   {
83773     try {
83774       (arg1)->Remove(arg2);
83775     } catch (std::out_of_range& e) {
83776       {
83777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83778       };
83779     } catch (std::exception& e) {
83780       {
83781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83782       };
83783     } catch (Dali::DaliException e) {
83784       {
83785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83786       };
83787     } catch (...) {
83788       {
83789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83790       };
83791     }
83792   }
83793
83794 }
83795
83796
83797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
83798   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83799
83800   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83801   {
83802     try {
83803       (arg1)->Activate();
83804     } catch (std::out_of_range& e) {
83805       {
83806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83807       };
83808     } catch (std::exception& e) {
83809       {
83810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83811       };
83812     } catch (Dali::DaliException e) {
83813       {
83814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83815       };
83816     } catch (...) {
83817       {
83818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83819       };
83820     }
83821   }
83822
83823 }
83824
83825
83826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
83827   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83828
83829   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83830   {
83831     try {
83832       (arg1)->ActivateOnce();
83833     } catch (std::out_of_range& e) {
83834       {
83835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83836       };
83837     } catch (std::exception& e) {
83838       {
83839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83840       };
83841     } catch (Dali::DaliException e) {
83842       {
83843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83844       };
83845     } catch (...) {
83846       {
83847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83848       };
83849     }
83850   }
83851
83852 }
83853
83854
83855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
83856   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83857
83858   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83859   {
83860     try {
83861       (arg1)->Deactivate();
83862     } catch (std::out_of_range& e) {
83863       {
83864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83865       };
83866     } catch (std::exception& e) {
83867       {
83868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83869       };
83870     } catch (Dali::DaliException e) {
83871       {
83872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83873       };
83874     } catch (...) {
83875       {
83876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83877       };
83878     }
83879   }
83880
83881 }
83882
83883
83884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
83885   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83886   Dali::Texture arg2 ;
83887   Dali::FrameBuffer arg3 ;
83888   Dali::Texture *argp2 ;
83889   Dali::FrameBuffer *argp3 ;
83890
83891   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83892   argp2 = (Dali::Texture *)jarg2;
83893   if (!argp2) {
83894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
83895     return ;
83896   }
83897   arg2 = *argp2;
83898   argp3 = (Dali::FrameBuffer *)jarg3;
83899   if (!argp3) {
83900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
83901     return ;
83902   }
83903   arg3 = *argp3;
83904   {
83905     try {
83906       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
83907     } catch (std::out_of_range& e) {
83908       {
83909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83910       };
83911     } catch (std::exception& e) {
83912       {
83913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83914       };
83915     } catch (Dali::DaliException e) {
83916       {
83917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83918       };
83919     } catch (...) {
83920       {
83921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83922       };
83923     }
83924   }
83925
83926 }
83927
83928
83929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
83930   int jresult ;
83931   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83932   Dali::Property::Index result;
83933
83934   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83935   {
83936     try {
83937       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
83938     } catch (std::out_of_range& e) {
83939       {
83940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83941       };
83942     } catch (std::exception& e) {
83943       {
83944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83945       };
83946     } catch (Dali::DaliException e) {
83947       {
83948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83949       };
83950     } catch (...) {
83951       {
83952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83953       };
83954     }
83955   }
83956
83957   jresult = result;
83958   return jresult;
83959 }
83960
83961
83962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
83963   void * jresult ;
83964   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83965   Dali::FrameBuffer result;
83966
83967   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83968   {
83969     try {
83970       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
83971     } catch (std::out_of_range& e) {
83972       {
83973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83974       };
83975     } catch (std::exception& e) {
83976       {
83977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83978       };
83979     } catch (Dali::DaliException e) {
83980       {
83981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83982       };
83983     } catch (...) {
83984       {
83985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83986       };
83987     }
83988   }
83989
83990   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
83991   return jresult;
83992 }
83993
83994
83995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
83996   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83997   Dali::Vector4 *arg2 = 0 ;
83998
83999   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84000   arg2 = (Dali::Vector4 *)jarg2;
84001   if (!arg2) {
84002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84003     return ;
84004   }
84005   {
84006     try {
84007       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84008     } catch (std::out_of_range& e) {
84009       {
84010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84011       };
84012     } catch (std::exception& e) {
84013       {
84014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84015       };
84016     } catch (Dali::DaliException e) {
84017       {
84018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84019       };
84020     } catch (...) {
84021       {
84022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84023       };
84024     }
84025   }
84026
84027 }
84028
84029
84030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84031   void * jresult ;
84032   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84033   Dali::Vector4 result;
84034
84035   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84036   {
84037     try {
84038       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84039     } catch (std::out_of_range& e) {
84040       {
84041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84042       };
84043     } catch (std::exception& e) {
84044       {
84045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84046       };
84047     } catch (Dali::DaliException e) {
84048       {
84049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84050       };
84051     } catch (...) {
84052       {
84053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84054       };
84055     }
84056   }
84057
84058   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84059   return jresult;
84060 }
84061
84062
84063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84064   void * jresult ;
84065   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84066   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84067
84068   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84069   {
84070     try {
84071       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
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 = (void *)result;
84092   return jresult;
84093 }
84094
84095
84096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84097   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84098
84099   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84100   {
84101     try {
84102       delete arg1;
84103     } catch (std::out_of_range& e) {
84104       {
84105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84106       };
84107     } catch (std::exception& e) {
84108       {
84109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84110       };
84111     } catch (Dali::DaliException e) {
84112       {
84113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84114       };
84115     } catch (...) {
84116       {
84117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84118       };
84119     }
84120   }
84121
84122 }
84123
84124
84125 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84126   unsigned int jresult ;
84127   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84128   unsigned int result;
84129
84130   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84131   {
84132     try {
84133       result = (unsigned int)(arg1)->GetNumberOfPages();
84134     } catch (std::out_of_range& e) {
84135       {
84136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84137       };
84138     } catch (std::exception& e) {
84139       {
84140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84141       };
84142     } catch (Dali::DaliException e) {
84143       {
84144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84145       };
84146     } catch (...) {
84147       {
84148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84149       };
84150     }
84151   }
84152
84153   jresult = result;
84154   return jresult;
84155 }
84156
84157
84158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84159   void * jresult ;
84160   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84161   unsigned int arg2 ;
84162   Dali::Texture result;
84163
84164   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84165   arg2 = (unsigned int)jarg2;
84166   {
84167     try {
84168       result = (arg1)->NewPage(arg2);
84169     } catch (std::out_of_range& e) {
84170       {
84171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84172       };
84173     } catch (std::exception& e) {
84174       {
84175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84176       };
84177     } catch (Dali::DaliException e) {
84178       {
84179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84180       };
84181     } catch (...) {
84182       {
84183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84184       };
84185     }
84186   }
84187
84188   jresult = new Dali::Texture((const Dali::Texture &)result);
84189   return jresult;
84190 }
84191
84192
84193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
84194   int jresult ;
84195   int result;
84196
84197   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
84198   jresult = (int)result;
84199   return jresult;
84200 }
84201
84202
84203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84204   int jresult ;
84205   int result;
84206
84207   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84208   jresult = (int)result;
84209   return jresult;
84210 }
84211
84212
84213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84214   int jresult ;
84215   int result;
84216
84217   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84218   jresult = (int)result;
84219   return jresult;
84220 }
84221
84222
84223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84224   void * jresult ;
84225   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84226
84227   {
84228     try {
84229       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84230     } catch (std::out_of_range& e) {
84231       {
84232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84233       };
84234     } catch (std::exception& e) {
84235       {
84236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84237       };
84238     } catch (Dali::DaliException e) {
84239       {
84240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84241       };
84242     } catch (...) {
84243       {
84244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84245       };
84246     }
84247   }
84248
84249   jresult = (void *)result;
84250   return jresult;
84251 }
84252
84253
84254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84255   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84256
84257   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84258   {
84259     try {
84260       delete arg1;
84261     } catch (std::out_of_range& e) {
84262       {
84263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84264       };
84265     } catch (std::exception& e) {
84266       {
84267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84268       };
84269     } catch (Dali::DaliException e) {
84270       {
84271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84272       };
84273     } catch (...) {
84274       {
84275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84276       };
84277     }
84278   }
84279
84280 }
84281
84282
84283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84284   void * jresult ;
84285   Dali::Toolkit::PageTurnView *result = 0 ;
84286
84287   {
84288     try {
84289       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84290     } catch (std::out_of_range& e) {
84291       {
84292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84293       };
84294     } catch (std::exception& e) {
84295       {
84296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84297       };
84298     } catch (Dali::DaliException e) {
84299       {
84300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84301       };
84302     } catch (...) {
84303       {
84304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84305       };
84306     }
84307   }
84308
84309   jresult = (void *)result;
84310   return jresult;
84311 }
84312
84313
84314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84315   void * jresult ;
84316   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84317   Dali::Toolkit::PageTurnView *result = 0 ;
84318
84319   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84320   if (!arg1) {
84321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84322     return 0;
84323   }
84324   {
84325     try {
84326       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84327     } catch (std::out_of_range& e) {
84328       {
84329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84330       };
84331     } catch (std::exception& e) {
84332       {
84333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84334       };
84335     } catch (Dali::DaliException e) {
84336       {
84337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84338       };
84339     } catch (...) {
84340       {
84341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84342       };
84343     }
84344   }
84345
84346   jresult = (void *)result;
84347   return jresult;
84348 }
84349
84350
84351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84352   void * jresult ;
84353   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84354   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84355   Dali::Toolkit::PageTurnView *result = 0 ;
84356
84357   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84358   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84359   if (!arg2) {
84360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84361     return 0;
84362   }
84363   {
84364     try {
84365       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84366     } catch (std::out_of_range& e) {
84367       {
84368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84369       };
84370     } catch (std::exception& e) {
84371       {
84372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84373       };
84374     } catch (Dali::DaliException e) {
84375       {
84376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84377       };
84378     } catch (...) {
84379       {
84380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84381       };
84382     }
84383   }
84384
84385   jresult = (void *)result;
84386   return jresult;
84387 }
84388
84389
84390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84391   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84392
84393   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84394   {
84395     try {
84396       delete arg1;
84397     } catch (std::out_of_range& e) {
84398       {
84399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84400       };
84401     } catch (std::exception& e) {
84402       {
84403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84404       };
84405     } catch (Dali::DaliException e) {
84406       {
84407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84408       };
84409     } catch (...) {
84410       {
84411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84412       };
84413     }
84414   }
84415
84416 }
84417
84418
84419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84420   void * jresult ;
84421   Dali::BaseHandle arg1 ;
84422   Dali::BaseHandle *argp1 ;
84423   Dali::Toolkit::PageTurnView result;
84424
84425   argp1 = (Dali::BaseHandle *)jarg1;
84426   if (!argp1) {
84427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84428     return 0;
84429   }
84430   arg1 = *argp1;
84431   {
84432     try {
84433       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84434     } catch (std::out_of_range& e) {
84435       {
84436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84437       };
84438     } catch (std::exception& e) {
84439       {
84440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84441       };
84442     } catch (Dali::DaliException e) {
84443       {
84444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84445       };
84446     } catch (...) {
84447       {
84448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84449       };
84450     }
84451   }
84452
84453   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84454   return jresult;
84455 }
84456
84457
84458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84459   void * jresult ;
84460   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84461   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84462
84463   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84464   {
84465     try {
84466       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84467     } catch (std::out_of_range& e) {
84468       {
84469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84470       };
84471     } catch (std::exception& e) {
84472       {
84473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84474       };
84475     } catch (Dali::DaliException e) {
84476       {
84477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84478       };
84479     } catch (...) {
84480       {
84481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84482       };
84483     }
84484   }
84485
84486   jresult = (void *)result;
84487   return jresult;
84488 }
84489
84490
84491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84492   void * jresult ;
84493   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84494   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84495
84496   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84497   {
84498     try {
84499       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84500     } catch (std::out_of_range& e) {
84501       {
84502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84503       };
84504     } catch (std::exception& e) {
84505       {
84506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84507       };
84508     } catch (Dali::DaliException e) {
84509       {
84510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84511       };
84512     } catch (...) {
84513       {
84514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84515       };
84516     }
84517   }
84518
84519   jresult = (void *)result;
84520   return jresult;
84521 }
84522
84523
84524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
84525   void * jresult ;
84526   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84527   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84528
84529   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84530   {
84531     try {
84532       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84533     } catch (std::out_of_range& e) {
84534       {
84535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84536       };
84537     } catch (std::exception& e) {
84538       {
84539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84540       };
84541     } catch (Dali::DaliException e) {
84542       {
84543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84544       };
84545     } catch (...) {
84546       {
84547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84548       };
84549     }
84550   }
84551
84552   jresult = (void *)result;
84553   return jresult;
84554 }
84555
84556
84557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84558   void * jresult ;
84559   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84560   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84561
84562   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84563   {
84564     try {
84565       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84566     } catch (std::out_of_range& e) {
84567       {
84568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84569       };
84570     } catch (std::exception& e) {
84571       {
84572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84573       };
84574     } catch (Dali::DaliException e) {
84575       {
84576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84577       };
84578     } catch (...) {
84579       {
84580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84581       };
84582     }
84583   }
84584
84585   jresult = (void *)result;
84586   return jresult;
84587 }
84588
84589
84590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
84591   void * jresult ;
84592   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84593
84594   {
84595     try {
84596       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84597     } catch (std::out_of_range& e) {
84598       {
84599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84600       };
84601     } catch (std::exception& e) {
84602       {
84603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84604       };
84605     } catch (Dali::DaliException e) {
84606       {
84607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84608       };
84609     } catch (...) {
84610       {
84611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84612       };
84613     }
84614   }
84615
84616   jresult = (void *)result;
84617   return jresult;
84618 }
84619
84620
84621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84622   void * jresult ;
84623   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84624   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84625
84626   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84627   if (!arg1) {
84628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84629     return 0;
84630   }
84631   {
84632     try {
84633       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
84634     } catch (std::out_of_range& e) {
84635       {
84636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84637       };
84638     } catch (std::exception& e) {
84639       {
84640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84641       };
84642     } catch (Dali::DaliException e) {
84643       {
84644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84645       };
84646     } catch (...) {
84647       {
84648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84649       };
84650     }
84651   }
84652
84653   jresult = (void *)result;
84654   return jresult;
84655 }
84656
84657
84658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
84659   void * jresult ;
84660   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84661   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
84662   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84663
84664   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84665   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
84666   if (!arg2) {
84667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84668     return 0;
84669   }
84670   {
84671     try {
84672       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
84673     } catch (std::out_of_range& e) {
84674       {
84675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84676       };
84677     } catch (std::exception& e) {
84678       {
84679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84680       };
84681     } catch (Dali::DaliException e) {
84682       {
84683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84684       };
84685     } catch (...) {
84686       {
84687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84688       };
84689     }
84690   }
84691
84692   jresult = (void *)result;
84693   return jresult;
84694 }
84695
84696
84697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
84698   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84699
84700   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84701   {
84702     try {
84703       delete arg1;
84704     } catch (std::out_of_range& e) {
84705       {
84706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84707       };
84708     } catch (std::exception& e) {
84709       {
84710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84711       };
84712     } catch (Dali::DaliException e) {
84713       {
84714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84715       };
84716     } catch (...) {
84717       {
84718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84719       };
84720     }
84721   }
84722
84723 }
84724
84725
84726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
84727   void * jresult ;
84728   Dali::Toolkit::PageFactory *arg1 = 0 ;
84729   Dali::Vector2 *arg2 = 0 ;
84730   Dali::Toolkit::PageTurnLandscapeView result;
84731
84732   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84733   if (!arg1) {
84734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84735     return 0;
84736   }
84737   arg2 = (Dali::Vector2 *)jarg2;
84738   if (!arg2) {
84739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84740     return 0;
84741   }
84742   {
84743     try {
84744       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
84745     } catch (std::out_of_range& e) {
84746       {
84747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84748       };
84749     } catch (std::exception& e) {
84750       {
84751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84752       };
84753     } catch (Dali::DaliException e) {
84754       {
84755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84756       };
84757     } catch (...) {
84758       {
84759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84760       };
84761     }
84762   }
84763
84764   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84765   return jresult;
84766 }
84767
84768
84769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
84770   void * jresult ;
84771   Dali::BaseHandle arg1 ;
84772   Dali::BaseHandle *argp1 ;
84773   Dali::Toolkit::PageTurnLandscapeView result;
84774
84775   argp1 = (Dali::BaseHandle *)jarg1;
84776   if (!argp1) {
84777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84778     return 0;
84779   }
84780   arg1 = *argp1;
84781   {
84782     try {
84783       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
84784     } catch (std::out_of_range& e) {
84785       {
84786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84787       };
84788     } catch (std::exception& e) {
84789       {
84790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84791       };
84792     } catch (Dali::DaliException e) {
84793       {
84794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84795       };
84796     } catch (...) {
84797       {
84798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84799       };
84800     }
84801   }
84802
84803   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84804   return jresult;
84805 }
84806
84807
84808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
84809   void * jresult ;
84810   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84811
84812   {
84813     try {
84814       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
84815     } catch (std::out_of_range& e) {
84816       {
84817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84818       };
84819     } catch (std::exception& e) {
84820       {
84821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84822       };
84823     } catch (Dali::DaliException e) {
84824       {
84825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84826       };
84827     } catch (...) {
84828       {
84829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84830       };
84831     }
84832   }
84833
84834   jresult = (void *)result;
84835   return jresult;
84836 }
84837
84838
84839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
84840   void * jresult ;
84841   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
84842   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84843
84844   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84845   if (!arg1) {
84846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
84847     return 0;
84848   }
84849   {
84850     try {
84851       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
84852     } catch (std::out_of_range& e) {
84853       {
84854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84855       };
84856     } catch (std::exception& e) {
84857       {
84858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84859       };
84860     } catch (Dali::DaliException e) {
84861       {
84862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84863       };
84864     } catch (...) {
84865       {
84866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84867       };
84868     }
84869   }
84870
84871   jresult = (void *)result;
84872   return jresult;
84873 }
84874
84875
84876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
84877   void * jresult ;
84878   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
84879   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
84880   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84881
84882   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84883   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
84884   if (!arg2) {
84885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
84886     return 0;
84887   }
84888   {
84889     try {
84890       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
84891     } catch (std::out_of_range& e) {
84892       {
84893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84894       };
84895     } catch (std::exception& e) {
84896       {
84897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84898       };
84899     } catch (Dali::DaliException e) {
84900       {
84901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84902       };
84903     } catch (...) {
84904       {
84905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84906       };
84907     }
84908   }
84909
84910   jresult = (void *)result;
84911   return jresult;
84912 }
84913
84914
84915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
84916   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
84917
84918   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
84919   {
84920     try {
84921       delete arg1;
84922     } catch (std::out_of_range& e) {
84923       {
84924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84925       };
84926     } catch (std::exception& e) {
84927       {
84928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84929       };
84930     } catch (Dali::DaliException e) {
84931       {
84932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84933       };
84934     } catch (...) {
84935       {
84936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84937       };
84938     }
84939   }
84940
84941 }
84942
84943
84944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
84945   void * jresult ;
84946   Dali::Toolkit::PageFactory *arg1 = 0 ;
84947   Dali::Vector2 *arg2 = 0 ;
84948   Dali::Toolkit::PageTurnPortraitView result;
84949
84950   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84951   if (!arg1) {
84952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84953     return 0;
84954   }
84955   arg2 = (Dali::Vector2 *)jarg2;
84956   if (!arg2) {
84957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84958     return 0;
84959   }
84960   {
84961     try {
84962       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
84963     } catch (std::out_of_range& e) {
84964       {
84965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84966       };
84967     } catch (std::exception& e) {
84968       {
84969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84970       };
84971     } catch (Dali::DaliException e) {
84972       {
84973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84974       };
84975     } catch (...) {
84976       {
84977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84978       };
84979     }
84980   }
84981
84982   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
84983   return jresult;
84984 }
84985
84986
84987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
84988   void * jresult ;
84989   Dali::BaseHandle arg1 ;
84990   Dali::BaseHandle *argp1 ;
84991   Dali::Toolkit::PageTurnPortraitView result;
84992
84993   argp1 = (Dali::BaseHandle *)jarg1;
84994   if (!argp1) {
84995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84996     return 0;
84997   }
84998   arg1 = *argp1;
84999   {
85000     try {
85001       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85002     } catch (std::out_of_range& e) {
85003       {
85004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85005       };
85006     } catch (std::exception& e) {
85007       {
85008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85009       };
85010     } catch (Dali::DaliException e) {
85011       {
85012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85013       };
85014     } catch (...) {
85015       {
85016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85017       };
85018     }
85019   }
85020
85021   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85022   return jresult;
85023 }
85024
85025
85026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85027   int jresult ;
85028   int result;
85029
85030   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85031   jresult = (int)result;
85032   return jresult;
85033 }
85034
85035
85036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85037   int jresult ;
85038   int result;
85039
85040   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85041   jresult = (int)result;
85042   return jresult;
85043 }
85044
85045
85046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85047   int jresult ;
85048   int result;
85049
85050   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85051   jresult = (int)result;
85052   return jresult;
85053 }
85054
85055
85056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85057   void * jresult ;
85058   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85059
85060   {
85061     try {
85062       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85063     } catch (std::out_of_range& e) {
85064       {
85065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85066       };
85067     } catch (std::exception& e) {
85068       {
85069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85070       };
85071     } catch (Dali::DaliException e) {
85072       {
85073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85074       };
85075     } catch (...) {
85076       {
85077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85078       };
85079     }
85080   }
85081
85082   jresult = (void *)result;
85083   return jresult;
85084 }
85085
85086
85087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85088   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85089
85090   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85091   {
85092     try {
85093       delete arg1;
85094     } catch (std::out_of_range& e) {
85095       {
85096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85097       };
85098     } catch (std::exception& e) {
85099       {
85100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85101       };
85102     } catch (Dali::DaliException e) {
85103       {
85104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85105       };
85106     } catch (...) {
85107       {
85108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85109       };
85110     }
85111   }
85112
85113 }
85114
85115
85116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85117   void * jresult ;
85118   Dali::Toolkit::ToggleButton *result = 0 ;
85119
85120   {
85121     try {
85122       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85123     } catch (std::out_of_range& e) {
85124       {
85125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85126       };
85127     } catch (std::exception& e) {
85128       {
85129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85130       };
85131     } catch (Dali::DaliException e) {
85132       {
85133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85134       };
85135     } catch (...) {
85136       {
85137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85138       };
85139     }
85140   }
85141
85142   jresult = (void *)result;
85143   return jresult;
85144 }
85145
85146
85147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85148   void * jresult ;
85149   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85150   Dali::Toolkit::ToggleButton *result = 0 ;
85151
85152   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85153   if (!arg1) {
85154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85155     return 0;
85156   }
85157   {
85158     try {
85159       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85160     } catch (std::out_of_range& e) {
85161       {
85162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85163       };
85164     } catch (std::exception& e) {
85165       {
85166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85167       };
85168     } catch (Dali::DaliException e) {
85169       {
85170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85171       };
85172     } catch (...) {
85173       {
85174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85175       };
85176     }
85177   }
85178
85179   jresult = (void *)result;
85180   return jresult;
85181 }
85182
85183
85184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85185   void * jresult ;
85186   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85187   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85188   Dali::Toolkit::ToggleButton *result = 0 ;
85189
85190   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85191   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85192   if (!arg2) {
85193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85194     return 0;
85195   }
85196   {
85197     try {
85198       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85199     } catch (std::out_of_range& e) {
85200       {
85201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85202       };
85203     } catch (std::exception& e) {
85204       {
85205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85206       };
85207     } catch (Dali::DaliException e) {
85208       {
85209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85210       };
85211     } catch (...) {
85212       {
85213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85214       };
85215     }
85216   }
85217
85218   jresult = (void *)result;
85219   return jresult;
85220 }
85221
85222
85223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85224   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85225
85226   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85227   {
85228     try {
85229       delete arg1;
85230     } catch (std::out_of_range& e) {
85231       {
85232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85233       };
85234     } catch (std::exception& e) {
85235       {
85236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85237       };
85238     } catch (Dali::DaliException e) {
85239       {
85240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85241       };
85242     } catch (...) {
85243       {
85244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85245       };
85246     }
85247   }
85248
85249 }
85250
85251
85252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85253   void * jresult ;
85254   Dali::Toolkit::ToggleButton result;
85255
85256   {
85257     try {
85258       result = Dali::Toolkit::ToggleButton::New();
85259     } catch (std::out_of_range& e) {
85260       {
85261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85262       };
85263     } catch (std::exception& e) {
85264       {
85265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85266       };
85267     } catch (Dali::DaliException e) {
85268       {
85269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85270       };
85271     } catch (...) {
85272       {
85273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85274       };
85275     }
85276   }
85277
85278   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85279   return jresult;
85280 }
85281
85282
85283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85284   void * jresult ;
85285   Dali::BaseHandle arg1 ;
85286   Dali::BaseHandle *argp1 ;
85287   Dali::Toolkit::ToggleButton result;
85288
85289   argp1 = (Dali::BaseHandle *)jarg1;
85290   if (!argp1) {
85291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85292     return 0;
85293   }
85294   arg1 = *argp1;
85295   {
85296     try {
85297       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
85298     } catch (std::out_of_range& e) {
85299       {
85300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85301       };
85302     } catch (std::exception& e) {
85303       {
85304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85305       };
85306     } catch (Dali::DaliException e) {
85307       {
85308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85309       };
85310     } catch (...) {
85311       {
85312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85313       };
85314     }
85315   }
85316
85317   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85318   return jresult;
85319 }
85320
85321
85322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85323   void * jresult ;
85324   Dali::Toolkit::Visual::Base *result = 0 ;
85325
85326   {
85327     try {
85328       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85329     } catch (std::out_of_range& e) {
85330       {
85331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85332       };
85333     } catch (std::exception& e) {
85334       {
85335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85336       };
85337     } catch (Dali::DaliException e) {
85338       {
85339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85340       };
85341     } catch (...) {
85342       {
85343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85344       };
85345     }
85346   }
85347
85348   jresult = (void *)result;
85349   return jresult;
85350 }
85351
85352
85353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85354   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85355
85356   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85357   {
85358     try {
85359       delete arg1;
85360     } catch (std::out_of_range& e) {
85361       {
85362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85363       };
85364     } catch (std::exception& e) {
85365       {
85366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85367       };
85368     } catch (Dali::DaliException e) {
85369       {
85370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85371       };
85372     } catch (...) {
85373       {
85374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85375       };
85376     }
85377   }
85378
85379 }
85380
85381
85382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85383   void * jresult ;
85384   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85385   Dali::Toolkit::Visual::Base *result = 0 ;
85386
85387   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85388   if (!arg1) {
85389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85390     return 0;
85391   }
85392   {
85393     try {
85394       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85395     } catch (std::out_of_range& e) {
85396       {
85397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85398       };
85399     } catch (std::exception& e) {
85400       {
85401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85402       };
85403     } catch (Dali::DaliException e) {
85404       {
85405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85406       };
85407     } catch (...) {
85408       {
85409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85410       };
85411     }
85412   }
85413
85414   jresult = (void *)result;
85415   return jresult;
85416 }
85417
85418
85419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85420   void * jresult ;
85421   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85422   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85423   Dali::Toolkit::Visual::Base *result = 0 ;
85424
85425   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85426   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85427   if (!arg2) {
85428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85429     return 0;
85430   }
85431   {
85432     try {
85433       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
85434     } catch (std::out_of_range& e) {
85435       {
85436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85437       };
85438     } catch (std::exception& e) {
85439       {
85440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85441       };
85442     } catch (Dali::DaliException e) {
85443       {
85444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85445       };
85446     } catch (...) {
85447       {
85448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85449       };
85450     }
85451   }
85452
85453   jresult = (void *)result;
85454   return jresult;
85455 }
85456
85457
85458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85459   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85460   std::string *arg2 = 0 ;
85461
85462   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85463   if (!jarg2) {
85464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85465     return ;
85466   }
85467   std::string arg2_str(jarg2);
85468   arg2 = &arg2_str;
85469   {
85470     try {
85471       (arg1)->SetName((std::string const &)*arg2);
85472     } catch (std::out_of_range& e) {
85473       {
85474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85475       };
85476     } catch (std::exception& e) {
85477       {
85478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85479       };
85480     } catch (Dali::DaliException e) {
85481       {
85482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85483       };
85484     } catch (...) {
85485       {
85486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85487       };
85488     }
85489   }
85490
85491
85492   //argout typemap for const std::string&
85493
85494 }
85495
85496
85497 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
85498   char * jresult ;
85499   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85500   std::string *result = 0 ;
85501
85502   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85503   {
85504     try {
85505       result = (std::string *) &(arg1)->GetName();
85506     } catch (std::out_of_range& e) {
85507       {
85508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85509       };
85510     } catch (std::exception& e) {
85511       {
85512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85513       };
85514     } catch (Dali::DaliException e) {
85515       {
85516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85517       };
85518     } catch (...) {
85519       {
85520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85521       };
85522     }
85523   }
85524
85525   jresult = SWIG_csharp_string_callback(result->c_str());
85526   return jresult;
85527 }
85528
85529
85530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
85531   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85532   Dali::Property::Map *arg2 = 0 ;
85533   Dali::Size arg3 ;
85534   Dali::Size *argp3 ;
85535
85536   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85537   arg2 = (Dali::Property::Map *)jarg2;
85538   if (!arg2) {
85539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85540     return ;
85541   }
85542   argp3 = (Dali::Size *)jarg3;
85543   if (!argp3) {
85544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
85545     return ;
85546   }
85547   arg3 = *argp3;
85548   {
85549     try {
85550       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
85551     } catch (std::out_of_range& e) {
85552       {
85553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85554       };
85555     } catch (std::exception& e) {
85556       {
85557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85558       };
85559     } catch (Dali::DaliException e) {
85560       {
85561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85562       };
85563     } catch (...) {
85564       {
85565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85566       };
85567     }
85568   }
85569
85570 }
85571
85572
85573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
85574   float jresult ;
85575   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85576   float arg2 ;
85577   float result;
85578
85579   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85580   arg2 = (float)jarg2;
85581   {
85582     try {
85583       result = (float)(arg1)->GetHeightForWidth(arg2);
85584     } catch (std::out_of_range& e) {
85585       {
85586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85587       };
85588     } catch (std::exception& e) {
85589       {
85590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85591       };
85592     } catch (Dali::DaliException e) {
85593       {
85594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85595       };
85596     } catch (...) {
85597       {
85598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85599       };
85600     }
85601   }
85602
85603   jresult = result;
85604   return jresult;
85605 }
85606
85607
85608 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
85609   float jresult ;
85610   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85611   float arg2 ;
85612   float result;
85613
85614   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85615   arg2 = (float)jarg2;
85616   {
85617     try {
85618       result = (float)(arg1)->GetWidthForHeight(arg2);
85619     } catch (std::out_of_range& e) {
85620       {
85621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85622       };
85623     } catch (std::exception& e) {
85624       {
85625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85626       };
85627     } catch (Dali::DaliException e) {
85628       {
85629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85630       };
85631     } catch (...) {
85632       {
85633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85634       };
85635     }
85636   }
85637
85638   jresult = result;
85639   return jresult;
85640 }
85641
85642
85643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
85644   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85645   Dali::Vector2 *arg2 = 0 ;
85646
85647   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85648   arg2 = (Dali::Vector2 *)jarg2;
85649   if (!arg2) {
85650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
85651     return ;
85652   }
85653   {
85654     try {
85655       (arg1)->GetNaturalSize(*arg2);
85656     } catch (std::out_of_range& e) {
85657       {
85658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85659       };
85660     } catch (std::exception& e) {
85661       {
85662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85663       };
85664     } catch (Dali::DaliException e) {
85665       {
85666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85667       };
85668     } catch (...) {
85669       {
85670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85671       };
85672     }
85673   }
85674
85675 }
85676
85677
85678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
85679   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85680   float arg2 ;
85681
85682   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85683   arg2 = (int)jarg2;
85684   {
85685     try {
85686       (arg1)->SetDepthIndex(arg2);
85687     } catch (std::out_of_range& e) {
85688       {
85689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85690       };
85691     } catch (std::exception& e) {
85692       {
85693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85694       };
85695     } catch (Dali::DaliException e) {
85696       {
85697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85698       };
85699     } catch (...) {
85700       {
85701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85702       };
85703     }
85704   }
85705
85706 }
85707
85708
85709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
85710   int jresult ;
85711   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85712   int result;
85713
85714   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85715   {
85716     try {
85717       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
85718     } catch (std::out_of_range& e) {
85719       {
85720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85721       };
85722     } catch (std::exception& e) {
85723       {
85724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85725       };
85726     } catch (Dali::DaliException e) {
85727       {
85728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85729       };
85730     } catch (...) {
85731       {
85732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85733       };
85734     }
85735   }
85736
85737   jresult = result;
85738   return jresult;
85739 }
85740
85741
85742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
85743   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85744   Dali::Property::Map *arg2 = 0 ;
85745
85746   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85747   arg2 = (Dali::Property::Map *)jarg2;
85748   if (!arg2) {
85749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
85750     return ;
85751   }
85752   {
85753     try {
85754       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
85755     } catch (std::out_of_range& e) {
85756       {
85757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85758       };
85759     } catch (std::exception& e) {
85760       {
85761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85762       };
85763     } catch (Dali::DaliException e) {
85764       {
85765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85766       };
85767     } catch (...) {
85768       {
85769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85770       };
85771     }
85772   }
85773
85774 }
85775
85776
85777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
85778   void * jresult ;
85779   Dali::Toolkit::VisualFactory result;
85780
85781   {
85782     try {
85783       result = Dali::Toolkit::VisualFactory::Get();
85784     } catch (std::out_of_range& e) {
85785       {
85786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85787       };
85788     } catch (std::exception& e) {
85789       {
85790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85791       };
85792     } catch (Dali::DaliException e) {
85793       {
85794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85795       };
85796     } catch (...) {
85797       {
85798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85799       };
85800     }
85801   }
85802
85803   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
85804   return jresult;
85805 }
85806
85807
85808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
85809   void * jresult ;
85810   Dali::Toolkit::VisualFactory *result = 0 ;
85811
85812   {
85813     try {
85814       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
85815     } catch (std::out_of_range& e) {
85816       {
85817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85818       };
85819     } catch (std::exception& e) {
85820       {
85821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85822       };
85823     } catch (Dali::DaliException e) {
85824       {
85825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85826       };
85827     } catch (...) {
85828       {
85829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85830       };
85831     }
85832   }
85833
85834   jresult = (void *)result;
85835   return jresult;
85836 }
85837
85838
85839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
85840   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85841
85842   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85843   {
85844     try {
85845       delete arg1;
85846     } catch (std::out_of_range& e) {
85847       {
85848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85849       };
85850     } catch (std::exception& e) {
85851       {
85852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85853       };
85854     } catch (Dali::DaliException e) {
85855       {
85856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85857       };
85858     } catch (...) {
85859       {
85860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85861       };
85862     }
85863   }
85864
85865 }
85866
85867
85868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
85869   void * jresult ;
85870   Dali::Toolkit::VisualFactory *arg1 = 0 ;
85871   Dali::Toolkit::VisualFactory *result = 0 ;
85872
85873   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85874   if (!arg1) {
85875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85876     return 0;
85877   }
85878   {
85879     try {
85880       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
85881     } catch (std::out_of_range& e) {
85882       {
85883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85884       };
85885     } catch (std::exception& e) {
85886       {
85887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85888       };
85889     } catch (Dali::DaliException e) {
85890       {
85891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85892       };
85893     } catch (...) {
85894       {
85895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85896       };
85897     }
85898   }
85899
85900   jresult = (void *)result;
85901   return jresult;
85902 }
85903
85904
85905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
85906   void * jresult ;
85907   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85908   Dali::Toolkit::VisualFactory *arg2 = 0 ;
85909   Dali::Toolkit::VisualFactory *result = 0 ;
85910
85911   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85912   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
85913   if (!arg2) {
85914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
85915     return 0;
85916   }
85917   {
85918     try {
85919       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
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 = (void *)result;
85940   return jresult;
85941 }
85942
85943
85944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
85945   void * jresult ;
85946   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85947   Dali::Property::Map *arg2 = 0 ;
85948   Dali::Toolkit::Visual::Base result;
85949
85950   arg1 = (Dali::Toolkit::VisualFactory *)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 0;
85955   }
85956   {
85957     try {
85958       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
85959     } catch (std::out_of_range& e) {
85960       {
85961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85962       };
85963     } catch (std::exception& e) {
85964       {
85965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85966       };
85967     } catch (Dali::DaliException e) {
85968       {
85969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85970       };
85971     } catch (...) {
85972       {
85973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85974       };
85975     }
85976   }
85977
85978   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
85979   return jresult;
85980 }
85981
85982
85983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
85984   void * jresult ;
85985   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
85986   std::string *arg2 = 0 ;
85987   Dali::ImageDimensions arg3 ;
85988   Dali::ImageDimensions *argp3 ;
85989   Dali::Toolkit::Visual::Base result;
85990
85991   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
85992   if (!jarg2) {
85993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85994     return 0;
85995   }
85996   std::string arg2_str(jarg2);
85997   arg2 = &arg2_str;
85998   argp3 = (Dali::ImageDimensions *)jarg3;
85999   if (!argp3) {
86000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86001     return 0;
86002   }
86003   arg3 = *argp3;
86004   {
86005     try {
86006       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
86007     } catch (std::out_of_range& e) {
86008       {
86009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86010       };
86011     } catch (std::exception& e) {
86012       {
86013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86014       };
86015     } catch (Dali::DaliException e) {
86016       {
86017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86018       };
86019     } catch (...) {
86020       {
86021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86022       };
86023     }
86024   }
86025
86026   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86027
86028   //argout typemap for const std::string&
86029
86030   return jresult;
86031 }
86032
86033
86034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
86035   void * jresult ;
86036   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86037
86038   {
86039     try {
86040       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
86041     } catch (std::out_of_range& e) {
86042       {
86043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86044       };
86045     } catch (std::exception& e) {
86046       {
86047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86048       };
86049     } catch (Dali::DaliException e) {
86050       {
86051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86052       };
86053     } catch (...) {
86054       {
86055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86056       };
86057     }
86058   }
86059
86060   jresult = (void *)result;
86061   return jresult;
86062 }
86063
86064
86065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86066   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86067
86068   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86069   {
86070     try {
86071       delete arg1;
86072     } catch (std::out_of_range& e) {
86073       {
86074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86075       };
86076     } catch (std::exception& e) {
86077       {
86078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86079       };
86080     } catch (Dali::DaliException e) {
86081       {
86082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86083       };
86084     } catch (...) {
86085       {
86086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86087       };
86088     }
86089   }
86090
86091 }
86092
86093
86094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86095   void * jresult ;
86096   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86097   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86098
86099   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86100   if (!arg1) {
86101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86102     return 0;
86103   }
86104   {
86105     try {
86106       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86107     } catch (std::out_of_range& e) {
86108       {
86109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86110       };
86111     } catch (std::exception& e) {
86112       {
86113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86114       };
86115     } catch (Dali::DaliException e) {
86116       {
86117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86118       };
86119     } catch (...) {
86120       {
86121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86122       };
86123     }
86124   }
86125
86126   jresult = (void *)result;
86127   return jresult;
86128 }
86129
86130
86131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86132   void * jresult ;
86133   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86134   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86135   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86136
86137   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86138   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86139   if (!arg2) {
86140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86141     return 0;
86142   }
86143   {
86144     try {
86145       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86146     } catch (std::out_of_range& e) {
86147       {
86148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86149       };
86150     } catch (std::exception& e) {
86151       {
86152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86153       };
86154     } catch (Dali::DaliException e) {
86155       {
86156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86157       };
86158     } catch (...) {
86159       {
86160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86161       };
86162     }
86163   }
86164
86165   jresult = (void *)result;
86166   return jresult;
86167 }
86168
86169
86170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86171   void * jresult ;
86172   Dali::Toolkit::AsyncImageLoader result;
86173
86174   {
86175     try {
86176       result = Dali::Toolkit::AsyncImageLoader::New();
86177     } catch (std::out_of_range& e) {
86178       {
86179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86180       };
86181     } catch (std::exception& e) {
86182       {
86183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86184       };
86185     } catch (Dali::DaliException e) {
86186       {
86187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86188       };
86189     } catch (...) {
86190       {
86191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86192       };
86193     }
86194   }
86195
86196   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86197   return jresult;
86198 }
86199
86200
86201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86202   void * jresult ;
86203   Dali::BaseHandle arg1 ;
86204   Dali::BaseHandle *argp1 ;
86205   Dali::Toolkit::AsyncImageLoader result;
86206
86207   argp1 = (Dali::BaseHandle *)jarg1;
86208   if (!argp1) {
86209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86210     return 0;
86211   }
86212   arg1 = *argp1;
86213   {
86214     try {
86215       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86216     } catch (std::out_of_range& e) {
86217       {
86218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86219       };
86220     } catch (std::exception& e) {
86221       {
86222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86223       };
86224     } catch (Dali::DaliException e) {
86225       {
86226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86227       };
86228     } catch (...) {
86229       {
86230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86231       };
86232     }
86233   }
86234
86235   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86236   return jresult;
86237 }
86238
86239
86240 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86241   unsigned int jresult ;
86242   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86243   std::string *arg2 = 0 ;
86244   uint32_t result;
86245
86246   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86247   if (!jarg2) {
86248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86249     return 0;
86250   }
86251   std::string arg2_str(jarg2);
86252   arg2 = &arg2_str;
86253   {
86254     try {
86255       result = (arg1)->Load((std::string const &)*arg2);
86256     } catch (std::out_of_range& e) {
86257       {
86258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86259       };
86260     } catch (std::exception& e) {
86261       {
86262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86263       };
86264     } catch (Dali::DaliException e) {
86265       {
86266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86267       };
86268     } catch (...) {
86269       {
86270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86271       };
86272     }
86273   }
86274
86275   jresult = result;
86276
86277   //argout typemap for const std::string&
86278
86279   return jresult;
86280 }
86281
86282
86283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86284   unsigned int jresult ;
86285   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86286   std::string *arg2 = 0 ;
86287   Dali::ImageDimensions arg3 ;
86288   Dali::ImageDimensions *argp3 ;
86289   uint32_t result;
86290
86291   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86292   if (!jarg2) {
86293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86294     return 0;
86295   }
86296   std::string arg2_str(jarg2);
86297   arg2 = &arg2_str;
86298   argp3 = (Dali::ImageDimensions *)jarg3;
86299   if (!argp3) {
86300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86301     return 0;
86302   }
86303   arg3 = *argp3;
86304   {
86305     try {
86306       result = (arg1)->Load((std::string const &)*arg2,arg3);
86307     } catch (std::out_of_range& e) {
86308       {
86309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86310       };
86311     } catch (std::exception& e) {
86312       {
86313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86314       };
86315     } catch (Dali::DaliException e) {
86316       {
86317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86318       };
86319     } catch (...) {
86320       {
86321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86322       };
86323     }
86324   }
86325
86326   jresult = result;
86327
86328   //argout typemap for const std::string&
86329
86330   return jresult;
86331 }
86332
86333
86334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86335   unsigned int jresult ;
86336   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86337   std::string *arg2 = 0 ;
86338   Dali::ImageDimensions arg3 ;
86339   Dali::FittingMode::Type arg4 ;
86340   Dali::SamplingMode::Type arg5 ;
86341   bool arg6 ;
86342   Dali::ImageDimensions *argp3 ;
86343   uint32_t result;
86344
86345   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86346   if (!jarg2) {
86347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86348     return 0;
86349   }
86350   std::string arg2_str(jarg2);
86351   arg2 = &arg2_str;
86352   argp3 = (Dali::ImageDimensions *)jarg3;
86353   if (!argp3) {
86354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86355     return 0;
86356   }
86357   arg3 = *argp3;
86358   arg4 = (Dali::FittingMode::Type)jarg4;
86359   arg5 = (Dali::SamplingMode::Type)jarg5;
86360   arg6 = jarg6 ? true : false;
86361   {
86362     try {
86363       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86364     } catch (std::out_of_range& e) {
86365       {
86366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86367       };
86368     } catch (std::exception& e) {
86369       {
86370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86371       };
86372     } catch (Dali::DaliException e) {
86373       {
86374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86375       };
86376     } catch (...) {
86377       {
86378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86379       };
86380     }
86381   }
86382
86383   jresult = result;
86384
86385   //argout typemap for const std::string&
86386
86387   return jresult;
86388 }
86389
86390
86391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86392   unsigned int jresult ;
86393   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86394   uint32_t arg2 ;
86395   bool result;
86396
86397   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86398   arg2 = (uint32_t)jarg2;
86399   {
86400     try {
86401       result = (bool)(arg1)->Cancel(arg2);
86402     } catch (std::out_of_range& e) {
86403       {
86404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86405       };
86406     } catch (std::exception& e) {
86407       {
86408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86409       };
86410     } catch (Dali::DaliException e) {
86411       {
86412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86413       };
86414     } catch (...) {
86415       {
86416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86417       };
86418     }
86419   }
86420
86421   jresult = result;
86422   return jresult;
86423 }
86424
86425
86426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86427   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86428
86429   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86430   {
86431     try {
86432       (arg1)->CancelAll();
86433     } catch (std::out_of_range& e) {
86434       {
86435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86436       };
86437     } catch (std::exception& e) {
86438       {
86439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86440       };
86441     } catch (Dali::DaliException e) {
86442       {
86443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86444       };
86445     } catch (...) {
86446       {
86447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86448       };
86449     }
86450   }
86451
86452 }
86453
86454
86455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86456   void * jresult ;
86457   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86458   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86459
86460   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86461   {
86462     try {
86463       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
86464     } catch (std::out_of_range& e) {
86465       {
86466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86467       };
86468     } catch (std::exception& e) {
86469       {
86470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86471       };
86472     } catch (Dali::DaliException e) {
86473       {
86474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86475       };
86476     } catch (...) {
86477       {
86478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86479       };
86480     }
86481   }
86482
86483   jresult = (void *)result;
86484   return jresult;
86485 }
86486
86487
86488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
86489   void * jresult ;
86490   std::string *arg1 = 0 ;
86491   Dali::PixelData result;
86492
86493   if (!jarg1) {
86494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86495     return 0;
86496   }
86497   std::string arg1_str(jarg1);
86498   arg1 = &arg1_str;
86499   {
86500     try {
86501       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
86502     } catch (std::out_of_range& e) {
86503       {
86504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86505       };
86506     } catch (std::exception& e) {
86507       {
86508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86509       };
86510     } catch (Dali::DaliException e) {
86511       {
86512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86513       };
86514     } catch (...) {
86515       {
86516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86517       };
86518     }
86519   }
86520
86521   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86522
86523   //argout typemap for const std::string&
86524
86525   return jresult;
86526 }
86527
86528
86529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
86530   void * jresult ;
86531   std::string *arg1 = 0 ;
86532   Dali::ImageDimensions arg2 ;
86533   Dali::ImageDimensions *argp2 ;
86534   Dali::PixelData result;
86535
86536   if (!jarg1) {
86537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86538     return 0;
86539   }
86540   std::string arg1_str(jarg1);
86541   arg1 = &arg1_str;
86542   argp2 = (Dali::ImageDimensions *)jarg2;
86543   if (!argp2) {
86544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86545     return 0;
86546   }
86547   arg2 = *argp2;
86548   {
86549     try {
86550       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
86551     } catch (std::out_of_range& e) {
86552       {
86553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86554       };
86555     } catch (std::exception& e) {
86556       {
86557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86558       };
86559     } catch (Dali::DaliException e) {
86560       {
86561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86562       };
86563     } catch (...) {
86564       {
86565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86566       };
86567     }
86568   }
86569
86570   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86571
86572   //argout typemap for const std::string&
86573
86574   return jresult;
86575 }
86576
86577
86578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
86579   void * jresult ;
86580   std::string *arg1 = 0 ;
86581   Dali::ImageDimensions arg2 ;
86582   Dali::FittingMode::Type arg3 ;
86583   Dali::SamplingMode::Type arg4 ;
86584   bool arg5 ;
86585   Dali::ImageDimensions *argp2 ;
86586   Dali::PixelData result;
86587
86588   if (!jarg1) {
86589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86590     return 0;
86591   }
86592   std::string arg1_str(jarg1);
86593   arg1 = &arg1_str;
86594   argp2 = (Dali::ImageDimensions *)jarg2;
86595   if (!argp2) {
86596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86597     return 0;
86598   }
86599   arg2 = *argp2;
86600   arg3 = (Dali::FittingMode::Type)jarg3;
86601   arg4 = (Dali::SamplingMode::Type)jarg4;
86602   arg5 = jarg5 ? true : false;
86603   {
86604     try {
86605       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
86606     } catch (std::out_of_range& e) {
86607       {
86608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86609       };
86610     } catch (std::exception& e) {
86611       {
86612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86613       };
86614     } catch (Dali::DaliException e) {
86615       {
86616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86617       };
86618     } catch (...) {
86619       {
86620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86621       };
86622     }
86623   }
86624
86625   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86626
86627   //argout typemap for const std::string&
86628
86629   return jresult;
86630 }
86631
86632
86633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
86634   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86635
86636   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86637   {
86638     try {
86639       delete arg1;
86640     } catch (std::out_of_range& e) {
86641       {
86642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86643       };
86644     } catch (std::exception& e) {
86645       {
86646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86647       };
86648     } catch (Dali::DaliException e) {
86649       {
86650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86651       };
86652     } catch (...) {
86653       {
86654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86655       };
86656     }
86657   }
86658
86659 }
86660
86661
86662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
86663   void * jresult ;
86664   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86665   Dali::Actor arg2 ;
86666   Dali::Actor arg3 ;
86667   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
86668   Dali::Actor *argp2 ;
86669   Dali::Actor *argp3 ;
86670   Dali::Actor result;
86671
86672   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86673   argp2 = (Dali::Actor *)jarg2;
86674   if (!argp2) {
86675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86676     return 0;
86677   }
86678   arg2 = *argp2;
86679   argp3 = (Dali::Actor *)jarg3;
86680   if (!argp3) {
86681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86682     return 0;
86683   }
86684   arg3 = *argp3;
86685   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
86686   {
86687     try {
86688       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
86689     } catch (std::out_of_range& e) {
86690       {
86691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86692       };
86693     } catch (std::exception& e) {
86694       {
86695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86696       };
86697     } catch (Dali::DaliException e) {
86698       {
86699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86700       };
86701     } catch (...) {
86702       {
86703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86704       };
86705     }
86706   }
86707
86708   jresult = new Dali::Actor((const Dali::Actor &)result);
86709   return jresult;
86710 }
86711
86712
86713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
86714   void * jresult ;
86715   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
86716
86717   {
86718     try {
86719       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
86720     } catch (std::out_of_range& e) {
86721       {
86722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86723       };
86724     } catch (std::exception& e) {
86725       {
86726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86727       };
86728     } catch (Dali::DaliException e) {
86729       {
86730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86731       };
86732     } catch (...) {
86733       {
86734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86735       };
86736     }
86737   }
86738
86739   jresult = (void *)result;
86740   return jresult;
86741 }
86742
86743
86744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
86745   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
86746   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
86747   if (director) {
86748     director->swig_connect_director(callback0);
86749   }
86750 }
86751
86752
86753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
86754   void * jresult ;
86755   Dali::FrameCallbackInterface *result = 0 ;
86756
86757   {
86758     try {
86759       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
86760     } catch (std::out_of_range& e) {
86761       {
86762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86763       };
86764     } catch (std::exception& e) {
86765       {
86766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86767       };
86768     } catch (Dali::DaliException e) {
86769       {
86770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86771       };
86772     } catch (...) {
86773       {
86774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86775       };
86776     }
86777   }
86778
86779   jresult = (void *)result;
86780   return jresult;
86781 }
86782
86783 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
86784   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86785   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
86786   return proxy->GetPosition(id, *vector3);
86787 }
86788
86789 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
86790   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86791   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
86792   return proxy->SetPosition(id, *vector3);
86793 }
86794
86795 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
86796   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86797   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
86798   return proxy->BakePosition(id, *vector3);
86799 }
86800
86801 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
86802   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86803   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
86804   return proxy->GetSize(id, *vector3);
86805 }
86806
86807 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
86808   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86809   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
86810   return proxy->SetSize(id, *vector3);
86811 }
86812 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
86813   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86814   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
86815   return proxy->BakeSize(id, *vector3);
86816 }
86817
86818 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
86819   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86820   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
86821   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
86822   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
86823 }
86824
86825 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
86826   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86827   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
86828   return proxy->GetScale(id,* vector3);
86829 }
86830
86831 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
86832   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86833   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
86834   return proxy->SetScale(id, *vector3);
86835 }
86836
86837 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
86838   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86839   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
86840   return proxy->BakeScale(id, *vector3);
86841 }
86842
86843 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
86844   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86845   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
86846   return proxy->GetColor(id, *vector4);
86847 }
86848
86849 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
86850   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86851   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
86852   return proxy->SetColor(id, *vector4);
86853 }
86854
86855 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
86856   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86857   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
86858   return proxy->BakeColor(id, *vector4);
86859 }
86860
86861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
86862   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
86863   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
86864
86865   Dali::Stage *arg1 = (Dali::Stage *) 0;
86866   Dali::Actor *arg3 = 0;
86867
86868   arg1 = (Dali::Stage *)jarg1;
86869   arg3 = (Dali::Actor *)jarg3;
86870
86871   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
86872   return;
86873 }
86874
86875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
86876
86877   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
86878   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
86879
86880   Dali::Stage *arg1 = (Dali::Stage *) 0;
86881
86882   arg1 = (Dali::Stage *)jarg1;
86883
86884   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
86885   return;
86886 }
86887
86888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
86889   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
86890   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
86891   if (director) {
86892     director->swig_connect_director(callback0);
86893   }
86894 }
86895
86896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
86897   KeyboardFocusManager arg1 ;
86898   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
86899   KeyboardFocusManager *argp1 ;
86900
86901   argp1 = (KeyboardFocusManager *)jarg1;
86902   if (!argp1) {
86903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
86904     return ;
86905   }
86906   arg1 = *argp1;
86907   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
86908   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
86909   {
86910     try {
86911       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
86912     } catch (std::out_of_range& e) {
86913       {
86914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86915       };
86916     } catch (std::exception& e) {
86917       {
86918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86919       };
86920     } catch (Dali::DaliException e) {
86921       {
86922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86923       };
86924     } catch (...) {
86925       {
86926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86927       };
86928     }
86929   }
86930
86931 }
86932
86933
86934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
86935   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86936
86937   arg1 = (std::vector< unsigned int > *)jarg1;
86938   {
86939     try {
86940       (arg1)->clear();
86941     } catch (std::out_of_range& e) {
86942       {
86943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86944       };
86945     } catch (std::exception& e) {
86946       {
86947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86948       };
86949     } catch (Dali::DaliException e) {
86950       {
86951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86952       };
86953     } catch (...) {
86954       {
86955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86956       };
86957     }
86958   }
86959
86960 }
86961
86962
86963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
86964   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86965   unsigned int *arg2 = 0 ;
86966   unsigned int temp2 ;
86967
86968   arg1 = (std::vector< unsigned int > *)jarg1;
86969   temp2 = (unsigned int)jarg2;
86970   arg2 = &temp2;
86971   {
86972     try {
86973       (arg1)->push_back((unsigned int const &)*arg2);
86974     } catch (std::out_of_range& e) {
86975       {
86976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86977       };
86978     } catch (std::exception& e) {
86979       {
86980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86981       };
86982     } catch (Dali::DaliException e) {
86983       {
86984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86985       };
86986     } catch (...) {
86987       {
86988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86989       };
86990     }
86991   }
86992
86993 }
86994
86995
86996 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
86997   unsigned long jresult ;
86998   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
86999   std::vector< unsigned int >::size_type result;
87000
87001   arg1 = (std::vector< unsigned int > *)jarg1;
87002   {
87003     try {
87004       result = ((std::vector< unsigned int > const *)arg1)->size();
87005     } catch (std::out_of_range& e) {
87006       {
87007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87008       };
87009     } catch (std::exception& e) {
87010       {
87011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87012       };
87013     } catch (Dali::DaliException e) {
87014       {
87015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87016       };
87017     } catch (...) {
87018       {
87019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87020       };
87021     }
87022   }
87023
87024   jresult = (unsigned long)result;
87025   return jresult;
87026 }
87027
87028
87029 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
87030   unsigned long jresult ;
87031   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87032   std::vector< unsigned int >::size_type result;
87033
87034   arg1 = (std::vector< unsigned int > *)jarg1;
87035   {
87036     try {
87037       result = ((std::vector< unsigned int > const *)arg1)->capacity();
87038     } catch (std::out_of_range& e) {
87039       {
87040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87041       };
87042     } catch (std::exception& e) {
87043       {
87044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87045       };
87046     } catch (Dali::DaliException e) {
87047       {
87048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87049       };
87050     } catch (...) {
87051       {
87052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87053       };
87054     }
87055   }
87056
87057   jresult = (unsigned long)result;
87058   return jresult;
87059 }
87060
87061
87062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
87063   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87064   std::vector< unsigned int >::size_type arg2 ;
87065
87066   arg1 = (std::vector< unsigned int > *)jarg1;
87067   arg2 = (std::vector< unsigned int >::size_type)jarg2;
87068   {
87069     try {
87070       (arg1)->reserve(arg2);
87071     } catch (std::out_of_range& e) {
87072       {
87073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87074       };
87075     } catch (std::exception& e) {
87076       {
87077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87078       };
87079     } catch (Dali::DaliException e) {
87080       {
87081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87082       };
87083     } catch (...) {
87084       {
87085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87086       };
87087     }
87088   }
87089
87090 }
87091
87092
87093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
87094   void * jresult ;
87095   std::vector< unsigned int > *result = 0 ;
87096
87097   {
87098     try {
87099       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
87100     } catch (std::out_of_range& e) {
87101       {
87102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87103       };
87104     } catch (std::exception& e) {
87105       {
87106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87107       };
87108     } catch (Dali::DaliException e) {
87109       {
87110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87111       };
87112     } catch (...) {
87113       {
87114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87115       };
87116     }
87117   }
87118
87119   jresult = (void *)result;
87120   return jresult;
87121 }
87122
87123
87124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
87125   void * jresult ;
87126   std::vector< unsigned int > *arg1 = 0 ;
87127   std::vector< unsigned int > *result = 0 ;
87128
87129   arg1 = (std::vector< unsigned int > *)jarg1;
87130   if (!arg1) {
87131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87132     return 0;
87133   }
87134   {
87135     try {
87136       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
87137     } catch (std::out_of_range& e) {
87138       {
87139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87140       };
87141     } catch (std::exception& e) {
87142       {
87143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87144       };
87145     } catch (Dali::DaliException e) {
87146       {
87147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87148       };
87149     } catch (...) {
87150       {
87151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87152       };
87153     }
87154   }
87155
87156   jresult = (void *)result;
87157   return jresult;
87158 }
87159
87160
87161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
87162   void * jresult ;
87163   int arg1 ;
87164   std::vector< unsigned int > *result = 0 ;
87165
87166   arg1 = (int)jarg1;
87167   {
87168     try {
87169       try {
87170         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
87171       }
87172       catch(std::out_of_range &_e) {
87173         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87174         return 0;
87175       }
87176
87177     } catch (std::out_of_range& e) {
87178       {
87179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87180       };
87181     } catch (std::exception& e) {
87182       {
87183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87184       };
87185     } catch (Dali::DaliException e) {
87186       {
87187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87188       };
87189     } catch (...) {
87190       {
87191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87192       };
87193     }
87194   }
87195
87196   jresult = (void *)result;
87197   return jresult;
87198 }
87199
87200
87201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
87202   unsigned int jresult ;
87203   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87204   int arg2 ;
87205   unsigned int result;
87206
87207   arg1 = (std::vector< unsigned int > *)jarg1;
87208   arg2 = (int)jarg2;
87209   {
87210     try {
87211       try {
87212         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
87213       }
87214       catch(std::out_of_range &_e) {
87215         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87216         return 0;
87217       }
87218
87219     } catch (std::out_of_range& e) {
87220       {
87221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87222       };
87223     } catch (std::exception& e) {
87224       {
87225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87226       };
87227     } catch (Dali::DaliException e) {
87228       {
87229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87230       };
87231     } catch (...) {
87232       {
87233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87234       };
87235     }
87236   }
87237
87238   jresult = result;
87239   return jresult;
87240 }
87241
87242
87243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
87244   unsigned int jresult ;
87245   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87246   int arg2 ;
87247   unsigned int *result = 0 ;
87248
87249   arg1 = (std::vector< unsigned int > *)jarg1;
87250   arg2 = (int)jarg2;
87251   {
87252     try {
87253       try {
87254         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
87255       }
87256       catch(std::out_of_range &_e) {
87257         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87258         return 0;
87259       }
87260
87261     } catch (std::out_of_range& e) {
87262       {
87263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87264       };
87265     } catch (std::exception& e) {
87266       {
87267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87268       };
87269     } catch (Dali::DaliException e) {
87270       {
87271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87272       };
87273     } catch (...) {
87274       {
87275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87276       };
87277     }
87278   }
87279
87280   jresult = *result;
87281   return jresult;
87282 }
87283
87284
87285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
87286   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87287   int arg2 ;
87288   unsigned int *arg3 = 0 ;
87289   unsigned int temp3 ;
87290
87291   arg1 = (std::vector< unsigned int > *)jarg1;
87292   arg2 = (int)jarg2;
87293   temp3 = (unsigned int)jarg3;
87294   arg3 = &temp3;
87295   {
87296     try {
87297       try {
87298         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87299       }
87300       catch(std::out_of_range &_e) {
87301         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87302         return ;
87303       }
87304
87305     } catch (std::out_of_range& e) {
87306       {
87307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87308       };
87309     } catch (std::exception& e) {
87310       {
87311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87312       };
87313     } catch (Dali::DaliException e) {
87314       {
87315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87316       };
87317     } catch (...) {
87318       {
87319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87320       };
87321     }
87322   }
87323
87324 }
87325
87326
87327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87328   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87329   std::vector< unsigned int > *arg2 = 0 ;
87330
87331   arg1 = (std::vector< unsigned int > *)jarg1;
87332   arg2 = (std::vector< unsigned int > *)jarg2;
87333   if (!arg2) {
87334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87335     return ;
87336   }
87337   {
87338     try {
87339       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87340     } catch (std::out_of_range& e) {
87341       {
87342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87343       };
87344     } catch (std::exception& e) {
87345       {
87346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87347       };
87348     } catch (Dali::DaliException e) {
87349       {
87350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87351       };
87352     } catch (...) {
87353       {
87354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87355       };
87356     }
87357   }
87358
87359 }
87360
87361
87362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87363   void * jresult ;
87364   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87365   int arg2 ;
87366   int arg3 ;
87367   std::vector< unsigned int > *result = 0 ;
87368
87369   arg1 = (std::vector< unsigned int > *)jarg1;
87370   arg2 = (int)jarg2;
87371   arg3 = (int)jarg3;
87372   {
87373     try {
87374       try {
87375         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87376       }
87377       catch(std::out_of_range &_e) {
87378         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87379         return 0;
87380       }
87381       catch(std::invalid_argument &_e) {
87382         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87383         return 0;
87384       }
87385
87386     } catch (std::out_of_range& e) {
87387       {
87388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87389       };
87390     } catch (std::exception& e) {
87391       {
87392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87393       };
87394     } catch (Dali::DaliException e) {
87395       {
87396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87397       };
87398     } catch (...) {
87399       {
87400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87401       };
87402     }
87403   }
87404
87405   jresult = (void *)result;
87406   return jresult;
87407 }
87408
87409
87410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87411   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87412   int arg2 ;
87413   unsigned int *arg3 = 0 ;
87414   unsigned int temp3 ;
87415
87416   arg1 = (std::vector< unsigned int > *)jarg1;
87417   arg2 = (int)jarg2;
87418   temp3 = (unsigned int)jarg3;
87419   arg3 = &temp3;
87420   {
87421     try {
87422       try {
87423         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87424       }
87425       catch(std::out_of_range &_e) {
87426         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87427         return ;
87428       }
87429
87430     } catch (std::out_of_range& e) {
87431       {
87432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87433       };
87434     } catch (std::exception& e) {
87435       {
87436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87437       };
87438     } catch (Dali::DaliException e) {
87439       {
87440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87441       };
87442     } catch (...) {
87443       {
87444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87445       };
87446     }
87447   }
87448
87449 }
87450
87451
87452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87453   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87454   int arg2 ;
87455   std::vector< unsigned int > *arg3 = 0 ;
87456
87457   arg1 = (std::vector< unsigned int > *)jarg1;
87458   arg2 = (int)jarg2;
87459   arg3 = (std::vector< unsigned int > *)jarg3;
87460   if (!arg3) {
87461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87462     return ;
87463   }
87464   {
87465     try {
87466       try {
87467         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87468       }
87469       catch(std::out_of_range &_e) {
87470         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87471         return ;
87472       }
87473
87474     } catch (std::out_of_range& e) {
87475       {
87476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87477       };
87478     } catch (std::exception& e) {
87479       {
87480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87481       };
87482     } catch (Dali::DaliException e) {
87483       {
87484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87485       };
87486     } catch (...) {
87487       {
87488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87489       };
87490     }
87491   }
87492
87493 }
87494
87495
87496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
87497   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87498   int arg2 ;
87499
87500   arg1 = (std::vector< unsigned int > *)jarg1;
87501   arg2 = (int)jarg2;
87502   {
87503     try {
87504       try {
87505         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
87506       }
87507       catch(std::out_of_range &_e) {
87508         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87509         return ;
87510       }
87511
87512     } catch (std::out_of_range& e) {
87513       {
87514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87515       };
87516     } catch (std::exception& e) {
87517       {
87518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87519       };
87520     } catch (Dali::DaliException e) {
87521       {
87522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87523       };
87524     } catch (...) {
87525       {
87526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87527       };
87528     }
87529   }
87530
87531 }
87532
87533
87534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87535   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87536   int arg2 ;
87537   int arg3 ;
87538
87539   arg1 = (std::vector< unsigned int > *)jarg1;
87540   arg2 = (int)jarg2;
87541   arg3 = (int)jarg3;
87542   {
87543     try {
87544       try {
87545         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
87546       }
87547       catch(std::out_of_range &_e) {
87548         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87549         return ;
87550       }
87551       catch(std::invalid_argument &_e) {
87552         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87553         return ;
87554       }
87555
87556     } catch (std::out_of_range& e) {
87557       {
87558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87559       };
87560     } catch (std::exception& e) {
87561       {
87562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87563       };
87564     } catch (Dali::DaliException e) {
87565       {
87566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87567       };
87568     } catch (...) {
87569       {
87570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87571       };
87572     }
87573   }
87574
87575 }
87576
87577
87578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
87579   void * jresult ;
87580   unsigned int *arg1 = 0 ;
87581   int arg2 ;
87582   unsigned int temp1 ;
87583   std::vector< unsigned int > *result = 0 ;
87584
87585   temp1 = (unsigned int)jarg1;
87586   arg1 = &temp1;
87587   arg2 = (int)jarg2;
87588   {
87589     try {
87590       try {
87591         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
87592       }
87593       catch(std::out_of_range &_e) {
87594         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87595         return 0;
87596       }
87597
87598     } catch (std::out_of_range& e) {
87599       {
87600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87601       };
87602     } catch (std::exception& e) {
87603       {
87604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87605       };
87606     } catch (Dali::DaliException e) {
87607       {
87608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87609       };
87610     } catch (...) {
87611       {
87612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87613       };
87614     }
87615   }
87616
87617   jresult = (void *)result;
87618   return jresult;
87619 }
87620
87621
87622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
87623   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87624
87625   arg1 = (std::vector< unsigned int > *)jarg1;
87626   {
87627     try {
87628       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
87629     } catch (std::out_of_range& e) {
87630       {
87631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87632       };
87633     } catch (std::exception& e) {
87634       {
87635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87636       };
87637     } catch (Dali::DaliException e) {
87638       {
87639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87640       };
87641     } catch (...) {
87642       {
87643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87644       };
87645     }
87646   }
87647
87648 }
87649
87650
87651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87652   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87653   int arg2 ;
87654   int arg3 ;
87655
87656   arg1 = (std::vector< unsigned int > *)jarg1;
87657   arg2 = (int)jarg2;
87658   arg3 = (int)jarg3;
87659   {
87660     try {
87661       try {
87662         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87663       }
87664       catch(std::out_of_range &_e) {
87665         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87666         return ;
87667       }
87668       catch(std::invalid_argument &_e) {
87669         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87670         return ;
87671       }
87672
87673     } catch (std::out_of_range& e) {
87674       {
87675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87676       };
87677     } catch (std::exception& e) {
87678       {
87679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87680       };
87681     } catch (Dali::DaliException e) {
87682       {
87683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87684       };
87685     } catch (...) {
87686       {
87687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87688       };
87689     }
87690   }
87691
87692 }
87693
87694
87695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87696   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87697   int arg2 ;
87698   std::vector< unsigned int > *arg3 = 0 ;
87699
87700   arg1 = (std::vector< unsigned int > *)jarg1;
87701   arg2 = (int)jarg2;
87702   arg3 = (std::vector< unsigned int > *)jarg3;
87703   if (!arg3) {
87704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87705     return ;
87706   }
87707   {
87708     try {
87709       try {
87710         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87711       }
87712       catch(std::out_of_range &_e) {
87713         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87714         return ;
87715       }
87716
87717     } catch (std::out_of_range& e) {
87718       {
87719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87720       };
87721     } catch (std::exception& e) {
87722       {
87723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87724       };
87725     } catch (Dali::DaliException e) {
87726       {
87727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87728       };
87729     } catch (...) {
87730       {
87731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87732       };
87733     }
87734   }
87735
87736 }
87737
87738
87739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
87740   unsigned int jresult ;
87741   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87742   unsigned int *arg2 = 0 ;
87743   unsigned int temp2 ;
87744   bool result;
87745
87746   arg1 = (std::vector< unsigned int > *)jarg1;
87747   temp2 = (unsigned int)jarg2;
87748   arg2 = &temp2;
87749   {
87750     try {
87751       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
87752     } catch (std::out_of_range& e) {
87753       {
87754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87755       };
87756     } catch (std::exception& e) {
87757       {
87758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87759       };
87760     } catch (Dali::DaliException e) {
87761       {
87762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87763       };
87764     } catch (...) {
87765       {
87766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87767       };
87768     }
87769   }
87770
87771   jresult = result;
87772   return jresult;
87773 }
87774
87775
87776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
87777   int jresult ;
87778   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87779   unsigned int *arg2 = 0 ;
87780   unsigned int temp2 ;
87781   int result;
87782
87783   arg1 = (std::vector< unsigned int > *)jarg1;
87784   temp2 = (unsigned int)jarg2;
87785   arg2 = &temp2;
87786   {
87787     try {
87788       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
87789     } catch (std::out_of_range& e) {
87790       {
87791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87792       };
87793     } catch (std::exception& e) {
87794       {
87795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87796       };
87797     } catch (Dali::DaliException e) {
87798       {
87799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87800       };
87801     } catch (...) {
87802       {
87803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87804       };
87805     }
87806   }
87807
87808   jresult = result;
87809   return jresult;
87810 }
87811
87812
87813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
87814   int jresult ;
87815   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87816   unsigned int *arg2 = 0 ;
87817   unsigned int temp2 ;
87818   int result;
87819
87820   arg1 = (std::vector< unsigned int > *)jarg1;
87821   temp2 = (unsigned int)jarg2;
87822   arg2 = &temp2;
87823   {
87824     try {
87825       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
87826     } catch (std::out_of_range& e) {
87827       {
87828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87829       };
87830     } catch (std::exception& e) {
87831       {
87832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87833       };
87834     } catch (Dali::DaliException e) {
87835       {
87836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87837       };
87838     } catch (...) {
87839       {
87840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87841       };
87842     }
87843   }
87844
87845   jresult = result;
87846   return jresult;
87847 }
87848
87849
87850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
87851   unsigned int jresult ;
87852   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87853   unsigned int *arg2 = 0 ;
87854   unsigned int temp2 ;
87855   bool result;
87856
87857   arg1 = (std::vector< unsigned int > *)jarg1;
87858   temp2 = (unsigned int)jarg2;
87859   arg2 = &temp2;
87860   {
87861     try {
87862       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
87863     } catch (std::out_of_range& e) {
87864       {
87865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87866       };
87867     } catch (std::exception& e) {
87868       {
87869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87870       };
87871     } catch (Dali::DaliException e) {
87872       {
87873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87874       };
87875     } catch (...) {
87876       {
87877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87878       };
87879     }
87880   }
87881
87882   jresult = result;
87883   return jresult;
87884 }
87885
87886
87887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
87888   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87889
87890   arg1 = (std::vector< unsigned int > *)jarg1;
87891   {
87892     try {
87893       delete arg1;
87894     } catch (std::out_of_range& e) {
87895       {
87896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87897       };
87898     } catch (std::exception& e) {
87899       {
87900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87901       };
87902     } catch (Dali::DaliException e) {
87903       {
87904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87905       };
87906     } catch (...) {
87907       {
87908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87909       };
87910     }
87911   }
87912
87913 }
87914
87915
87916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
87917   void * jresult ;
87918   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87919
87920   {
87921     try {
87922       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
87923     } catch (std::out_of_range& e) {
87924       {
87925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87926       };
87927     } catch (std::exception& e) {
87928       {
87929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87930       };
87931     } catch (Dali::DaliException e) {
87932       {
87933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87934       };
87935     } catch (...) {
87936       {
87937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87938       };
87939     }
87940   }
87941
87942   jresult = (void *)result;
87943   return jresult;
87944 }
87945
87946
87947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
87948   void * jresult ;
87949   unsigned int arg1 ;
87950   Dali::Actor arg2 ;
87951   Dali::Actor *argp2 ;
87952   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87953
87954   arg1 = (unsigned int)jarg1;
87955   argp2 = (Dali::Actor *)jarg2;
87956   if (!argp2) {
87957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87958     return 0;
87959   }
87960   arg2 = *argp2;
87961   {
87962     try {
87963       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
87964     } catch (std::out_of_range& e) {
87965       {
87966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87967       };
87968     } catch (std::exception& e) {
87969       {
87970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87971       };
87972     } catch (Dali::DaliException e) {
87973       {
87974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87975       };
87976     } catch (...) {
87977       {
87978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87979       };
87980     }
87981   }
87982
87983   jresult = (void *)result;
87984   return jresult;
87985 }
87986
87987
87988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
87989   void * jresult ;
87990   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
87991   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87992
87993   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
87994   if (!arg1) {
87995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
87996     return 0;
87997   }
87998   {
87999     try {
88000       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
88001     } catch (std::out_of_range& e) {
88002       {
88003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88004       };
88005     } catch (std::exception& e) {
88006       {
88007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88008       };
88009     } catch (Dali::DaliException e) {
88010       {
88011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88012       };
88013     } catch (...) {
88014       {
88015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88016       };
88017     }
88018   }
88019
88020   jresult = (void *)result;
88021   return jresult;
88022 }
88023
88024
88025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
88026   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88027   unsigned int arg2 ;
88028
88029   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88030   arg2 = (unsigned int)jarg2;
88031   if (arg1) (arg1)->first = arg2;
88032 }
88033
88034
88035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
88036   unsigned int jresult ;
88037   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88038   unsigned int result;
88039
88040   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88041   result = (unsigned int) ((arg1)->first);
88042   jresult = result;
88043   return jresult;
88044 }
88045
88046
88047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
88048   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88049   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
88050
88051   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88052   arg2 = (Dali::Actor *)jarg2;
88053   if (arg1) (arg1)->second = *arg2;
88054 }
88055
88056
88057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
88058   void * jresult ;
88059   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88060   Dali::Actor *result = 0 ;
88061
88062   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88063   result = (Dali::Actor *)& ((arg1)->second);
88064   jresult = (void *)result;
88065   return jresult;
88066 }
88067
88068
88069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
88070   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88071
88072   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88073   {
88074     try {
88075       delete arg1;
88076     } catch (std::out_of_range& e) {
88077       {
88078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88079       };
88080     } catch (std::exception& e) {
88081       {
88082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88083       };
88084     } catch (Dali::DaliException e) {
88085       {
88086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88087       };
88088     } catch (...) {
88089       {
88090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88091       };
88092     }
88093   }
88094
88095 }
88096
88097
88098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
88099   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88100
88101   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88102   {
88103     try {
88104       (arg1)->clear();
88105     } catch (std::out_of_range& e) {
88106       {
88107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88108       };
88109     } catch (std::exception& e) {
88110       {
88111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88112       };
88113     } catch (Dali::DaliException e) {
88114       {
88115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88116       };
88117     } catch (...) {
88118       {
88119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88120       };
88121     }
88122   }
88123
88124 }
88125
88126
88127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
88128   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88129   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
88130
88131   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88132   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
88133   if (!arg2) {
88134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88135     return ;
88136   }
88137   {
88138     try {
88139       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
88140     } catch (std::out_of_range& e) {
88141       {
88142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88143       };
88144     } catch (std::exception& e) {
88145       {
88146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88147       };
88148     } catch (Dali::DaliException e) {
88149       {
88150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88151       };
88152     } catch (...) {
88153       {
88154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88155       };
88156     }
88157   }
88158
88159 }
88160
88161
88162 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
88163   unsigned long jresult ;
88164   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88165   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88166
88167   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88168   {
88169     try {
88170       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
88171     } catch (std::out_of_range& e) {
88172       {
88173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88174       };
88175     } catch (std::exception& e) {
88176       {
88177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88178       };
88179     } catch (Dali::DaliException e) {
88180       {
88181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88182       };
88183     } catch (...) {
88184       {
88185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88186       };
88187     }
88188   }
88189
88190   jresult = (unsigned long)result;
88191   return jresult;
88192 }
88193
88194
88195 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
88196   unsigned long jresult ;
88197   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88198   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88199
88200   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88201   {
88202     try {
88203       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
88204     } catch (std::out_of_range& e) {
88205       {
88206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88207       };
88208     } catch (std::exception& e) {
88209       {
88210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88211       };
88212     } catch (Dali::DaliException e) {
88213       {
88214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88215       };
88216     } catch (...) {
88217       {
88218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88219       };
88220     }
88221   }
88222
88223   jresult = (unsigned long)result;
88224   return jresult;
88225 }
88226
88227
88228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
88229   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88230   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
88231
88232   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88233   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
88234   {
88235     try {
88236       (arg1)->reserve(arg2);
88237     } catch (std::out_of_range& e) {
88238       {
88239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88240       };
88241     } catch (std::exception& e) {
88242       {
88243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88244       };
88245     } catch (Dali::DaliException e) {
88246       {
88247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88248       };
88249     } catch (...) {
88250       {
88251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88252       };
88253     }
88254   }
88255
88256 }
88257
88258
88259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
88260   void * jresult ;
88261   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88262
88263   {
88264     try {
88265       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
88266     } catch (std::out_of_range& e) {
88267       {
88268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88269       };
88270     } catch (std::exception& e) {
88271       {
88272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88273       };
88274     } catch (Dali::DaliException e) {
88275       {
88276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88277       };
88278     } catch (...) {
88279       {
88280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88281       };
88282     }
88283   }
88284
88285   jresult = (void *)result;
88286   return jresult;
88287 }
88288
88289
88290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
88291   void * jresult ;
88292   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
88293   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88294
88295   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88296   if (!arg1) {
88297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88298     return 0;
88299   }
88300   {
88301     try {
88302       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);
88303     } catch (std::out_of_range& e) {
88304       {
88305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88306       };
88307     } catch (std::exception& e) {
88308       {
88309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88310       };
88311     } catch (Dali::DaliException e) {
88312       {
88313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88314       };
88315     } catch (...) {
88316       {
88317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88318       };
88319     }
88320   }
88321
88322   jresult = (void *)result;
88323   return jresult;
88324 }
88325
88326
88327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
88328   void * jresult ;
88329   int arg1 ;
88330   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88331
88332   arg1 = (int)jarg1;
88333   {
88334     try {
88335       try {
88336         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);
88337       }
88338       catch(std::out_of_range &_e) {
88339         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88340         return 0;
88341       }
88342
88343     } catch (std::out_of_range& e) {
88344       {
88345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88346       };
88347     } catch (std::exception& e) {
88348       {
88349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88350       };
88351     } catch (Dali::DaliException e) {
88352       {
88353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88354       };
88355     } catch (...) {
88356       {
88357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88358       };
88359     }
88360   }
88361
88362   jresult = (void *)result;
88363   return jresult;
88364 }
88365
88366
88367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
88368   void * jresult ;
88369   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88370   int arg2 ;
88371   std::pair< unsigned int,Dali::Actor > result;
88372
88373   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88374   arg2 = (int)jarg2;
88375   {
88376     try {
88377       try {
88378         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
88379       }
88380       catch(std::out_of_range &_e) {
88381         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88382         return 0;
88383       }
88384
88385     } catch (std::out_of_range& e) {
88386       {
88387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88388       };
88389     } catch (std::exception& e) {
88390       {
88391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88392       };
88393     } catch (Dali::DaliException e) {
88394       {
88395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88396       };
88397     } catch (...) {
88398       {
88399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88400       };
88401     }
88402   }
88403
88404   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
88405   return jresult;
88406 }
88407
88408
88409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
88410   void * jresult ;
88411   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88412   int arg2 ;
88413   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88414
88415   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88416   arg2 = (int)jarg2;
88417   {
88418     try {
88419       try {
88420         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
88421       }
88422       catch(std::out_of_range &_e) {
88423         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88424         return 0;
88425       }
88426
88427     } catch (std::out_of_range& e) {
88428       {
88429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88430       };
88431     } catch (std::exception& e) {
88432       {
88433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88434       };
88435     } catch (Dali::DaliException e) {
88436       {
88437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88438       };
88439     } catch (...) {
88440       {
88441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88442       };
88443     }
88444   }
88445
88446   jresult = (void *)result;
88447   return jresult;
88448 }
88449
88450
88451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88452   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88453   int arg2 ;
88454   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88455
88456   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88457   arg2 = (int)jarg2;
88458   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88459   if (!arg3) {
88460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88461     return ;
88462   }
88463   {
88464     try {
88465       try {
88466         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);
88467       }
88468       catch(std::out_of_range &_e) {
88469         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88470         return ;
88471       }
88472
88473     } catch (std::out_of_range& e) {
88474       {
88475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88476       };
88477     } catch (std::exception& e) {
88478       {
88479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88480       };
88481     } catch (Dali::DaliException e) {
88482       {
88483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88484       };
88485     } catch (...) {
88486       {
88487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88488       };
88489     }
88490   }
88491
88492 }
88493
88494
88495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
88496   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88497   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
88498
88499   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88500   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
88501   if (!arg2) {
88502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88503     return ;
88504   }
88505   {
88506     try {
88507       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);
88508     } catch (std::out_of_range& e) {
88509       {
88510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88511       };
88512     } catch (std::exception& e) {
88513       {
88514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88515       };
88516     } catch (Dali::DaliException e) {
88517       {
88518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88519       };
88520     } catch (...) {
88521       {
88522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88523       };
88524     }
88525   }
88526
88527 }
88528
88529
88530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88531   void * jresult ;
88532   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88533   int arg2 ;
88534   int arg3 ;
88535   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88536
88537   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88538   arg2 = (int)jarg2;
88539   arg3 = (int)jarg3;
88540   {
88541     try {
88542       try {
88543         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);
88544       }
88545       catch(std::out_of_range &_e) {
88546         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88547         return 0;
88548       }
88549       catch(std::invalid_argument &_e) {
88550         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88551         return 0;
88552       }
88553
88554     } catch (std::out_of_range& e) {
88555       {
88556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88557       };
88558     } catch (std::exception& e) {
88559       {
88560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88561       };
88562     } catch (Dali::DaliException e) {
88563       {
88564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88565       };
88566     } catch (...) {
88567       {
88568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88569       };
88570     }
88571   }
88572
88573   jresult = (void *)result;
88574   return jresult;
88575 }
88576
88577
88578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88579   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88580   int arg2 ;
88581   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88582
88583   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88584   arg2 = (int)jarg2;
88585   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88586   if (!arg3) {
88587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88588     return ;
88589   }
88590   {
88591     try {
88592       try {
88593         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);
88594       }
88595       catch(std::out_of_range &_e) {
88596         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88597         return ;
88598       }
88599
88600     } catch (std::out_of_range& e) {
88601       {
88602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88603       };
88604     } catch (std::exception& e) {
88605       {
88606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88607       };
88608     } catch (Dali::DaliException e) {
88609       {
88610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88611       };
88612     } catch (...) {
88613       {
88614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88615       };
88616     }
88617   }
88618
88619 }
88620
88621
88622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88623   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88624   int arg2 ;
88625   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88626
88627   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88628   arg2 = (int)jarg2;
88629   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88630   if (!arg3) {
88631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88632     return ;
88633   }
88634   {
88635     try {
88636       try {
88637         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);
88638       }
88639       catch(std::out_of_range &_e) {
88640         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88641         return ;
88642       }
88643
88644     } catch (std::out_of_range& e) {
88645       {
88646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88647       };
88648     } catch (std::exception& e) {
88649       {
88650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88651       };
88652     } catch (Dali::DaliException e) {
88653       {
88654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88655       };
88656     } catch (...) {
88657       {
88658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88659       };
88660     }
88661   }
88662
88663 }
88664
88665
88666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
88667   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88668   int arg2 ;
88669
88670   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88671   arg2 = (int)jarg2;
88672   {
88673     try {
88674       try {
88675         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
88676       }
88677       catch(std::out_of_range &_e) {
88678         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88679         return ;
88680       }
88681
88682     } catch (std::out_of_range& e) {
88683       {
88684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88685       };
88686     } catch (std::exception& e) {
88687       {
88688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88689       };
88690     } catch (Dali::DaliException e) {
88691       {
88692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88693       };
88694     } catch (...) {
88695       {
88696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88697       };
88698     }
88699   }
88700
88701 }
88702
88703
88704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88705   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88706   int arg2 ;
88707   int arg3 ;
88708
88709   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88710   arg2 = (int)jarg2;
88711   arg3 = (int)jarg3;
88712   {
88713     try {
88714       try {
88715         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
88716       }
88717       catch(std::out_of_range &_e) {
88718         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88719         return ;
88720       }
88721       catch(std::invalid_argument &_e) {
88722         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88723         return ;
88724       }
88725
88726     } catch (std::out_of_range& e) {
88727       {
88728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88729       };
88730     } catch (std::exception& e) {
88731       {
88732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88733       };
88734     } catch (Dali::DaliException e) {
88735       {
88736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88737       };
88738     } catch (...) {
88739       {
88740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88741       };
88742     }
88743   }
88744
88745 }
88746
88747
88748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
88749   void * jresult ;
88750   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88751   int arg2 ;
88752   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88753
88754   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88755   if (!arg1) {
88756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88757     return 0;
88758   }
88759   arg2 = (int)jarg2;
88760   {
88761     try {
88762       try {
88763         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);
88764       }
88765       catch(std::out_of_range &_e) {
88766         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88767         return 0;
88768       }
88769
88770     } catch (std::out_of_range& e) {
88771       {
88772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88773       };
88774     } catch (std::exception& e) {
88775       {
88776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88777       };
88778     } catch (Dali::DaliException e) {
88779       {
88780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88781       };
88782     } catch (...) {
88783       {
88784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88785       };
88786     }
88787   }
88788
88789   jresult = (void *)result;
88790   return jresult;
88791 }
88792
88793
88794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
88795   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88796
88797   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88798   {
88799     try {
88800       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
88801     } catch (std::out_of_range& e) {
88802       {
88803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88804       };
88805     } catch (std::exception& e) {
88806       {
88807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88808       };
88809     } catch (Dali::DaliException e) {
88810       {
88811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88812       };
88813     } catch (...) {
88814       {
88815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88816       };
88817     }
88818   }
88819
88820 }
88821
88822
88823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88824   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88825   int arg2 ;
88826   int arg3 ;
88827
88828   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88829   arg2 = (int)jarg2;
88830   arg3 = (int)jarg3;
88831   {
88832     try {
88833       try {
88834         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88835       }
88836       catch(std::out_of_range &_e) {
88837         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88838         return ;
88839       }
88840       catch(std::invalid_argument &_e) {
88841         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88842         return ;
88843       }
88844
88845     } catch (std::out_of_range& e) {
88846       {
88847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88848       };
88849     } catch (std::exception& e) {
88850       {
88851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88852       };
88853     } catch (Dali::DaliException e) {
88854       {
88855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88856       };
88857     } catch (...) {
88858       {
88859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88860       };
88861     }
88862   }
88863
88864 }
88865
88866
88867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88868   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88869   int arg2 ;
88870   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88871
88872   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88873   arg2 = (int)jarg2;
88874   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88875   if (!arg3) {
88876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88877     return ;
88878   }
88879   {
88880     try {
88881       try {
88882         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);
88883       }
88884       catch(std::out_of_range &_e) {
88885         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88886         return ;
88887       }
88888
88889     } catch (std::out_of_range& e) {
88890       {
88891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88892       };
88893     } catch (std::exception& e) {
88894       {
88895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88896       };
88897     } catch (Dali::DaliException e) {
88898       {
88899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88900       };
88901     } catch (...) {
88902       {
88903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88904       };
88905     }
88906   }
88907
88908 }
88909
88910
88911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
88912   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88913
88914   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88915   {
88916     try {
88917       delete arg1;
88918     } catch (std::out_of_range& e) {
88919       {
88920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88921       };
88922     } catch (std::exception& e) {
88923       {
88924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88925       };
88926     } catch (Dali::DaliException e) {
88927       {
88928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88929       };
88930     } catch (...) {
88931       {
88932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88933       };
88934     }
88935   }
88936
88937 }
88938
88939
88940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
88941   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88942
88943   arg1 = (std::vector< Dali::Actor > *)jarg1;
88944   {
88945     try {
88946       (arg1)->clear();
88947     } catch (std::out_of_range& e) {
88948       {
88949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88950       };
88951     } catch (std::exception& e) {
88952       {
88953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88954       };
88955     } catch (Dali::DaliException e) {
88956       {
88957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88958       };
88959     } catch (...) {
88960       {
88961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88962       };
88963     }
88964   }
88965
88966 }
88967
88968
88969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
88970   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
88971   Dali::Actor *arg2 = 0 ;
88972
88973   arg1 = (std::vector< Dali::Actor > *)jarg1;
88974   arg2 = (Dali::Actor *)jarg2;
88975   if (!arg2) {
88976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
88977     return ;
88978   }
88979   {
88980     try {
88981       (arg1)->push_back((Dali::Actor const &)*arg2);
88982     } catch (std::out_of_range& e) {
88983       {
88984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88985       };
88986     } catch (std::exception& e) {
88987       {
88988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88989       };
88990     } catch (Dali::DaliException e) {
88991       {
88992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88993       };
88994     } catch (...) {
88995       {
88996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88997       };
88998     }
88999   }
89000
89001 }
89002
89003
89004 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
89005   unsigned long jresult ;
89006   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89007   std::vector< Dali::Actor >::size_type result;
89008
89009   arg1 = (std::vector< Dali::Actor > *)jarg1;
89010   {
89011     try {
89012       result = ((std::vector< Dali::Actor > const *)arg1)->size();
89013     } catch (std::out_of_range& e) {
89014       {
89015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89016       };
89017     } catch (std::exception& e) {
89018       {
89019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89020       };
89021     } catch (Dali::DaliException e) {
89022       {
89023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89024       };
89025     } catch (...) {
89026       {
89027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89028       };
89029     }
89030   }
89031
89032   jresult = (unsigned long)result;
89033   return jresult;
89034 }
89035
89036
89037 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
89038   unsigned long jresult ;
89039   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89040   std::vector< Dali::Actor >::size_type result;
89041
89042   arg1 = (std::vector< Dali::Actor > *)jarg1;
89043   {
89044     try {
89045       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
89046     } catch (std::out_of_range& e) {
89047       {
89048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89049       };
89050     } catch (std::exception& e) {
89051       {
89052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89053       };
89054     } catch (Dali::DaliException e) {
89055       {
89056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89057       };
89058     } catch (...) {
89059       {
89060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89061       };
89062     }
89063   }
89064
89065   jresult = (unsigned long)result;
89066   return jresult;
89067 }
89068
89069
89070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
89071   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89072   std::vector< Dali::Actor >::size_type arg2 ;
89073
89074   arg1 = (std::vector< Dali::Actor > *)jarg1;
89075   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
89076   {
89077     try {
89078       (arg1)->reserve(arg2);
89079     } catch (std::out_of_range& e) {
89080       {
89081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89082       };
89083     } catch (std::exception& e) {
89084       {
89085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89086       };
89087     } catch (Dali::DaliException e) {
89088       {
89089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89090       };
89091     } catch (...) {
89092       {
89093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89094       };
89095     }
89096   }
89097
89098 }
89099
89100
89101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
89102   void * jresult ;
89103   std::vector< Dali::Actor > *result = 0 ;
89104
89105   {
89106     try {
89107       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
89108     } catch (std::out_of_range& e) {
89109       {
89110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89111       };
89112     } catch (std::exception& e) {
89113       {
89114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89115       };
89116     } catch (Dali::DaliException e) {
89117       {
89118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89119       };
89120     } catch (...) {
89121       {
89122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89123       };
89124     }
89125   }
89126
89127   jresult = (void *)result;
89128   return jresult;
89129 }
89130
89131
89132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
89133   void * jresult ;
89134   std::vector< Dali::Actor > *arg1 = 0 ;
89135   std::vector< Dali::Actor > *result = 0 ;
89136
89137   arg1 = (std::vector< Dali::Actor > *)jarg1;
89138   if (!arg1) {
89139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89140     return 0;
89141   }
89142   {
89143     try {
89144       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
89145     } catch (std::out_of_range& e) {
89146       {
89147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89148       };
89149     } catch (std::exception& e) {
89150       {
89151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89152       };
89153     } catch (Dali::DaliException e) {
89154       {
89155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89156       };
89157     } catch (...) {
89158       {
89159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89160       };
89161     }
89162   }
89163
89164   jresult = (void *)result;
89165   return jresult;
89166 }
89167
89168
89169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
89170   void * jresult ;
89171   int arg1 ;
89172   std::vector< Dali::Actor > *result = 0 ;
89173
89174   arg1 = (int)jarg1;
89175   {
89176     try {
89177       try {
89178         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
89179       }
89180       catch(std::out_of_range &_e) {
89181         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89182         return 0;
89183       }
89184
89185     } catch (std::out_of_range& e) {
89186       {
89187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89188       };
89189     } catch (std::exception& e) {
89190       {
89191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89192       };
89193     } catch (Dali::DaliException e) {
89194       {
89195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89196       };
89197     } catch (...) {
89198       {
89199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89200       };
89201     }
89202   }
89203
89204   jresult = (void *)result;
89205   return jresult;
89206 }
89207
89208
89209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
89210   void * jresult ;
89211   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89212   int arg2 ;
89213   Dali::Actor result;
89214
89215   arg1 = (std::vector< Dali::Actor > *)jarg1;
89216   arg2 = (int)jarg2;
89217   {
89218     try {
89219       try {
89220         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
89221       }
89222       catch(std::out_of_range &_e) {
89223         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89224         return 0;
89225       }
89226
89227     } catch (std::out_of_range& e) {
89228       {
89229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89230       };
89231     } catch (std::exception& e) {
89232       {
89233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89234       };
89235     } catch (Dali::DaliException e) {
89236       {
89237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89238       };
89239     } catch (...) {
89240       {
89241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89242       };
89243     }
89244   }
89245
89246   jresult = new Dali::Actor((const Dali::Actor &)result);
89247   return jresult;
89248 }
89249
89250
89251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
89252   void * jresult ;
89253   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89254   int arg2 ;
89255   Dali::Actor *result = 0 ;
89256
89257   arg1 = (std::vector< Dali::Actor > *)jarg1;
89258   arg2 = (int)jarg2;
89259   {
89260     try {
89261       try {
89262         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
89263       }
89264       catch(std::out_of_range &_e) {
89265         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89266         return 0;
89267       }
89268
89269     } catch (std::out_of_range& e) {
89270       {
89271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89272       };
89273     } catch (std::exception& e) {
89274       {
89275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89276       };
89277     } catch (Dali::DaliException e) {
89278       {
89279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89280       };
89281     } catch (...) {
89282       {
89283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89284       };
89285     }
89286   }
89287
89288   jresult = (void *)result;
89289   return jresult;
89290 }
89291
89292
89293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
89294   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89295   int arg2 ;
89296   Dali::Actor *arg3 = 0 ;
89297
89298   arg1 = (std::vector< Dali::Actor > *)jarg1;
89299   arg2 = (int)jarg2;
89300   arg3 = (Dali::Actor *)jarg3;
89301   if (!arg3) {
89302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89303     return ;
89304   }
89305   {
89306     try {
89307       try {
89308         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
89309       }
89310       catch(std::out_of_range &_e) {
89311         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89312         return ;
89313       }
89314
89315     } catch (std::out_of_range& e) {
89316       {
89317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89318       };
89319     } catch (std::exception& e) {
89320       {
89321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89322       };
89323     } catch (Dali::DaliException e) {
89324       {
89325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89326       };
89327     } catch (...) {
89328       {
89329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89330       };
89331     }
89332   }
89333
89334 }
89335
89336
89337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
89338   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89339   std::vector< Dali::Actor > *arg2 = 0 ;
89340
89341   arg1 = (std::vector< Dali::Actor > *)jarg1;
89342   arg2 = (std::vector< Dali::Actor > *)jarg2;
89343   if (!arg2) {
89344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89345     return ;
89346   }
89347   {
89348     try {
89349       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
89350     } catch (std::out_of_range& e) {
89351       {
89352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89353       };
89354     } catch (std::exception& e) {
89355       {
89356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89357       };
89358     } catch (Dali::DaliException e) {
89359       {
89360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89361       };
89362     } catch (...) {
89363       {
89364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89365       };
89366     }
89367   }
89368
89369 }
89370
89371
89372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
89373   void * jresult ;
89374   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89375   int arg2 ;
89376   int arg3 ;
89377   std::vector< Dali::Actor > *result = 0 ;
89378
89379   arg1 = (std::vector< Dali::Actor > *)jarg1;
89380   arg2 = (int)jarg2;
89381   arg3 = (int)jarg3;
89382   {
89383     try {
89384       try {
89385         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
89386       }
89387       catch(std::out_of_range &_e) {
89388         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89389         return 0;
89390       }
89391       catch(std::invalid_argument &_e) {
89392         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89393         return 0;
89394       }
89395
89396     } catch (std::out_of_range& e) {
89397       {
89398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89399       };
89400     } catch (std::exception& e) {
89401       {
89402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89403       };
89404     } catch (Dali::DaliException e) {
89405       {
89406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89407       };
89408     } catch (...) {
89409       {
89410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89411       };
89412     }
89413   }
89414
89415   jresult = (void *)result;
89416   return jresult;
89417 }
89418
89419
89420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
89421   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89422   int arg2 ;
89423   Dali::Actor *arg3 = 0 ;
89424
89425   arg1 = (std::vector< Dali::Actor > *)jarg1;
89426   arg2 = (int)jarg2;
89427   arg3 = (Dali::Actor *)jarg3;
89428   if (!arg3) {
89429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89430     return ;
89431   }
89432   {
89433     try {
89434       try {
89435         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
89436       }
89437       catch(std::out_of_range &_e) {
89438         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89439         return ;
89440       }
89441
89442     } catch (std::out_of_range& e) {
89443       {
89444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89445       };
89446     } catch (std::exception& e) {
89447       {
89448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89449       };
89450     } catch (Dali::DaliException e) {
89451       {
89452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89453       };
89454     } catch (...) {
89455       {
89456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89457       };
89458     }
89459   }
89460
89461 }
89462
89463
89464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89465   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89466   int arg2 ;
89467   std::vector< Dali::Actor > *arg3 = 0 ;
89468
89469   arg1 = (std::vector< Dali::Actor > *)jarg1;
89470   arg2 = (int)jarg2;
89471   arg3 = (std::vector< Dali::Actor > *)jarg3;
89472   if (!arg3) {
89473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89474     return ;
89475   }
89476   {
89477     try {
89478       try {
89479         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89480       }
89481       catch(std::out_of_range &_e) {
89482         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89483         return ;
89484       }
89485
89486     } catch (std::out_of_range& e) {
89487       {
89488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89489       };
89490     } catch (std::exception& e) {
89491       {
89492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89493       };
89494     } catch (Dali::DaliException e) {
89495       {
89496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89497       };
89498     } catch (...) {
89499       {
89500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89501       };
89502     }
89503   }
89504
89505 }
89506
89507
89508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
89509   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89510   int arg2 ;
89511
89512   arg1 = (std::vector< Dali::Actor > *)jarg1;
89513   arg2 = (int)jarg2;
89514   {
89515     try {
89516       try {
89517         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
89518       }
89519       catch(std::out_of_range &_e) {
89520         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89521         return ;
89522       }
89523
89524     } catch (std::out_of_range& e) {
89525       {
89526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89527       };
89528     } catch (std::exception& e) {
89529       {
89530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89531       };
89532     } catch (Dali::DaliException e) {
89533       {
89534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89535       };
89536     } catch (...) {
89537       {
89538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89539       };
89540     }
89541   }
89542
89543 }
89544
89545
89546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89547   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89548   int arg2 ;
89549   int arg3 ;
89550
89551   arg1 = (std::vector< Dali::Actor > *)jarg1;
89552   arg2 = (int)jarg2;
89553   arg3 = (int)jarg3;
89554   {
89555     try {
89556       try {
89557         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
89558       }
89559       catch(std::out_of_range &_e) {
89560         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89561         return ;
89562       }
89563       catch(std::invalid_argument &_e) {
89564         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89565         return ;
89566       }
89567
89568     } catch (std::out_of_range& e) {
89569       {
89570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89571       };
89572     } catch (std::exception& e) {
89573       {
89574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89575       };
89576     } catch (Dali::DaliException e) {
89577       {
89578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89579       };
89580     } catch (...) {
89581       {
89582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89583       };
89584     }
89585   }
89586
89587 }
89588
89589
89590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
89591   void * jresult ;
89592   Dali::Actor *arg1 = 0 ;
89593   int arg2 ;
89594   std::vector< Dali::Actor > *result = 0 ;
89595
89596   arg1 = (Dali::Actor *)jarg1;
89597   if (!arg1) {
89598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89599     return 0;
89600   }
89601   arg2 = (int)jarg2;
89602   {
89603     try {
89604       try {
89605         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
89606       }
89607       catch(std::out_of_range &_e) {
89608         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89609         return 0;
89610       }
89611
89612     } catch (std::out_of_range& e) {
89613       {
89614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89615       };
89616     } catch (std::exception& e) {
89617       {
89618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89619       };
89620     } catch (Dali::DaliException e) {
89621       {
89622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89623       };
89624     } catch (...) {
89625       {
89626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89627       };
89628     }
89629   }
89630
89631   jresult = (void *)result;
89632   return jresult;
89633 }
89634
89635
89636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
89637   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89638
89639   arg1 = (std::vector< Dali::Actor > *)jarg1;
89640   {
89641     try {
89642       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
89643     } catch (std::out_of_range& e) {
89644       {
89645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89646       };
89647     } catch (std::exception& e) {
89648       {
89649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89650       };
89651     } catch (Dali::DaliException e) {
89652       {
89653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89654       };
89655     } catch (...) {
89656       {
89657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89658       };
89659     }
89660   }
89661
89662 }
89663
89664
89665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89666   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89667   int arg2 ;
89668   int arg3 ;
89669
89670   arg1 = (std::vector< Dali::Actor > *)jarg1;
89671   arg2 = (int)jarg2;
89672   arg3 = (int)jarg3;
89673   {
89674     try {
89675       try {
89676         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89677       }
89678       catch(std::out_of_range &_e) {
89679         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89680         return ;
89681       }
89682       catch(std::invalid_argument &_e) {
89683         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89684         return ;
89685       }
89686
89687     } catch (std::out_of_range& e) {
89688       {
89689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89690       };
89691     } catch (std::exception& e) {
89692       {
89693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89694       };
89695     } catch (Dali::DaliException e) {
89696       {
89697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89698       };
89699     } catch (...) {
89700       {
89701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89702       };
89703     }
89704   }
89705
89706 }
89707
89708
89709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89710   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89711   int arg2 ;
89712   std::vector< Dali::Actor > *arg3 = 0 ;
89713
89714   arg1 = (std::vector< Dali::Actor > *)jarg1;
89715   arg2 = (int)jarg2;
89716   arg3 = (std::vector< Dali::Actor > *)jarg3;
89717   if (!arg3) {
89718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89719     return ;
89720   }
89721   {
89722     try {
89723       try {
89724         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89725       }
89726       catch(std::out_of_range &_e) {
89727         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89728         return ;
89729       }
89730
89731     } catch (std::out_of_range& e) {
89732       {
89733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89734       };
89735     } catch (std::exception& e) {
89736       {
89737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89738       };
89739     } catch (Dali::DaliException e) {
89740       {
89741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89742       };
89743     } catch (...) {
89744       {
89745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89746       };
89747     }
89748   }
89749
89750 }
89751
89752
89753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
89754   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89755
89756   arg1 = (std::vector< Dali::Actor > *)jarg1;
89757   {
89758     try {
89759       delete arg1;
89760     } catch (std::out_of_range& e) {
89761       {
89762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89763       };
89764     } catch (std::exception& e) {
89765       {
89766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89767       };
89768     } catch (Dali::DaliException e) {
89769       {
89770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89771       };
89772     } catch (...) {
89773       {
89774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89775       };
89776     }
89777   }
89778
89779 }
89780
89781
89782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
89783   unsigned int jresult ;
89784   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89785   bool result;
89786
89787   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89788   {
89789     try {
89790       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89791     } catch (std::out_of_range& e) {
89792       {
89793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89794       };
89795     } catch (std::exception& e) {
89796       {
89797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89798       };
89799     } catch (Dali::DaliException e) {
89800       {
89801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89802       };
89803     } catch (...) {
89804       {
89805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89806       };
89807     }
89808   }
89809
89810   jresult = result;
89811   return jresult;
89812 }
89813
89814
89815 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
89816   unsigned long jresult ;
89817   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89818   std::size_t result;
89819
89820   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89821   {
89822     try {
89823       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89824     } catch (std::out_of_range& e) {
89825       {
89826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89827       };
89828     } catch (std::exception& e) {
89829       {
89830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89831       };
89832     } catch (Dali::DaliException e) {
89833       {
89834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89835       };
89836     } catch (...) {
89837       {
89838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89839       };
89840     }
89841   }
89842
89843   jresult = (unsigned long)result;
89844   return jresult;
89845 }
89846
89847
89848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
89849   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89850   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89851
89852   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89853   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89854   {
89855     try {
89856       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
89857     } catch (std::out_of_range& e) {
89858       {
89859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89860       };
89861     } catch (std::exception& e) {
89862       {
89863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89864       };
89865     } catch (Dali::DaliException e) {
89866       {
89867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89868       };
89869     } catch (...) {
89870       {
89871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89872       };
89873     }
89874   }
89875
89876 }
89877
89878
89879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
89880   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89881   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89882
89883   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89884   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89885   {
89886     try {
89887       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
89888     } catch (std::out_of_range& e) {
89889       {
89890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89891       };
89892     } catch (std::exception& e) {
89893       {
89894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89895       };
89896     } catch (Dali::DaliException e) {
89897       {
89898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89899       };
89900     } catch (...) {
89901       {
89902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89903       };
89904     }
89905   }
89906
89907 }
89908
89909
89910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
89911   unsigned int jresult ;
89912   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89913   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
89914   bool result;
89915
89916   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89917   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
89918   if (!arg2) {
89919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
89920     return 0;
89921   }
89922   {
89923     try {
89924       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
89925     } catch (std::out_of_range& e) {
89926       {
89927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89928       };
89929     } catch (std::exception& e) {
89930       {
89931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89932       };
89933     } catch (Dali::DaliException e) {
89934       {
89935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89936       };
89937     } catch (...) {
89938       {
89939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89940       };
89941     }
89942   }
89943
89944   jresult = result;
89945   return jresult;
89946 }
89947
89948
89949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
89950   void * jresult ;
89951   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
89952
89953   {
89954     try {
89955       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
89956     } catch (std::out_of_range& e) {
89957       {
89958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89959       };
89960     } catch (std::exception& e) {
89961       {
89962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89963       };
89964     } catch (Dali::DaliException e) {
89965       {
89966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89967       };
89968     } catch (...) {
89969       {
89970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89971       };
89972     }
89973   }
89974
89975   jresult = (void *)result;
89976   return jresult;
89977 }
89978
89979
89980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
89981   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89982
89983   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89984   {
89985     try {
89986       delete arg1;
89987     } catch (std::out_of_range& e) {
89988       {
89989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89990       };
89991     } catch (std::exception& e) {
89992       {
89993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89994       };
89995     } catch (Dali::DaliException e) {
89996       {
89997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89998       };
89999     } catch (...) {
90000       {
90001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90002       };
90003     }
90004   }
90005
90006 }
90007
90008
90009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
90010   unsigned int jresult ;
90011   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90012   bool result;
90013
90014   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90015   {
90016     try {
90017       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);
90018     } catch (std::out_of_range& e) {
90019       {
90020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90021       };
90022     } catch (std::exception& e) {
90023       {
90024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90025       };
90026     } catch (Dali::DaliException e) {
90027       {
90028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90029       };
90030     } catch (...) {
90031       {
90032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90033       };
90034     }
90035   }
90036
90037   jresult = result;
90038   return jresult;
90039 }
90040
90041
90042 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
90043   unsigned long jresult ;
90044   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90045   std::size_t result;
90046
90047   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90048   {
90049     try {
90050       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);
90051     } catch (std::out_of_range& e) {
90052       {
90053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90054       };
90055     } catch (std::exception& e) {
90056       {
90057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90058       };
90059     } catch (Dali::DaliException e) {
90060       {
90061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90062       };
90063     } catch (...) {
90064       {
90065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90066       };
90067     }
90068   }
90069
90070   jresult = (unsigned long)result;
90071   return jresult;
90072 }
90073
90074
90075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
90076   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90077   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90078
90079   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90080   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90081   {
90082     try {
90083       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
90084     } catch (std::out_of_range& e) {
90085       {
90086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90087       };
90088     } catch (std::exception& e) {
90089       {
90090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90091       };
90092     } catch (Dali::DaliException e) {
90093       {
90094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90095       };
90096     } catch (...) {
90097       {
90098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90099       };
90100     }
90101   }
90102
90103 }
90104
90105
90106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
90107   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90108   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90109
90110   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90111   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90112   {
90113     try {
90114       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
90115     } catch (std::out_of_range& e) {
90116       {
90117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90118       };
90119     } catch (std::exception& e) {
90120       {
90121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90122       };
90123     } catch (Dali::DaliException e) {
90124       {
90125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90126       };
90127     } catch (...) {
90128       {
90129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90130       };
90131     }
90132   }
90133
90134 }
90135
90136
90137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90138   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90139   Dali::Actor arg2 ;
90140   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
90141   Dali::Actor *argp2 ;
90142
90143   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90144   argp2 = (Dali::Actor *)jarg2;
90145   if (!argp2) {
90146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90147     return ;
90148   }
90149   arg2 = *argp2;
90150   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
90151   {
90152     try {
90153       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
90154     } catch (std::out_of_range& e) {
90155       {
90156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90157       };
90158     } catch (std::exception& e) {
90159       {
90160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90161       };
90162     } catch (Dali::DaliException e) {
90163       {
90164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90165       };
90166     } catch (...) {
90167       {
90168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90169       };
90170     }
90171   }
90172
90173 }
90174
90175
90176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
90177   void * jresult ;
90178   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
90179
90180   {
90181     try {
90182       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
90183     } catch (std::out_of_range& e) {
90184       {
90185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90186       };
90187     } catch (std::exception& e) {
90188       {
90189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90190       };
90191     } catch (Dali::DaliException e) {
90192       {
90193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90194       };
90195     } catch (...) {
90196       {
90197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90198       };
90199     }
90200   }
90201
90202   jresult = (void *)result;
90203   return jresult;
90204 }
90205
90206
90207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
90208   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90209
90210   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90211   {
90212     try {
90213       delete arg1;
90214     } catch (std::out_of_range& e) {
90215       {
90216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90217       };
90218     } catch (std::exception& e) {
90219       {
90220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90221       };
90222     } catch (Dali::DaliException e) {
90223       {
90224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90225       };
90226     } catch (...) {
90227       {
90228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90229       };
90230     }
90231   }
90232
90233 }
90234
90235
90236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
90237   unsigned int jresult ;
90238   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90239   bool result;
90240
90241   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90242   {
90243     try {
90244       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90245     } catch (std::out_of_range& e) {
90246       {
90247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90248       };
90249     } catch (std::exception& e) {
90250       {
90251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90252       };
90253     } catch (Dali::DaliException e) {
90254       {
90255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90256       };
90257     } catch (...) {
90258       {
90259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90260       };
90261     }
90262   }
90263
90264   jresult = result;
90265   return jresult;
90266 }
90267
90268
90269 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
90270   unsigned long jresult ;
90271   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90272   std::size_t result;
90273
90274   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90275   {
90276     try {
90277       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90278     } catch (std::out_of_range& e) {
90279       {
90280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90281       };
90282     } catch (std::exception& e) {
90283       {
90284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90285       };
90286     } catch (Dali::DaliException e) {
90287       {
90288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90289       };
90290     } catch (...) {
90291       {
90292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90293       };
90294     }
90295   }
90296
90297   jresult = (unsigned long)result;
90298   return jresult;
90299 }
90300
90301
90302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
90303   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90304   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90305
90306   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90307   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90308   {
90309     try {
90310       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
90311     } catch (std::out_of_range& e) {
90312       {
90313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90314       };
90315     } catch (std::exception& e) {
90316       {
90317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90318       };
90319     } catch (Dali::DaliException e) {
90320       {
90321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90322       };
90323     } catch (...) {
90324       {
90325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90326       };
90327     }
90328   }
90329
90330 }
90331
90332
90333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90334   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90335   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90336
90337   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90338   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90339   {
90340     try {
90341       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
90342     } catch (std::out_of_range& e) {
90343       {
90344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90345       };
90346     } catch (std::exception& e) {
90347       {
90348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90349       };
90350     } catch (Dali::DaliException e) {
90351       {
90352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90353       };
90354     } catch (...) {
90355       {
90356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90357       };
90358     }
90359   }
90360
90361 }
90362
90363
90364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90365   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90366   Dali::Actor arg2 ;
90367   Dali::Actor arg3 ;
90368   Dali::Actor *argp2 ;
90369   Dali::Actor *argp3 ;
90370
90371   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90372   argp2 = (Dali::Actor *)jarg2;
90373   if (!argp2) {
90374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90375     return ;
90376   }
90377   arg2 = *argp2;
90378   argp3 = (Dali::Actor *)jarg3;
90379   if (!argp3) {
90380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90381     return ;
90382   }
90383   arg3 = *argp3;
90384   {
90385     try {
90386       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
90387     } catch (std::out_of_range& e) {
90388       {
90389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90390       };
90391     } catch (std::exception& e) {
90392       {
90393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90394       };
90395     } catch (Dali::DaliException e) {
90396       {
90397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90398       };
90399     } catch (...) {
90400       {
90401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90402       };
90403     }
90404   }
90405
90406 }
90407
90408
90409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
90410   void * jresult ;
90411   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
90412
90413   {
90414     try {
90415       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
90416     } catch (std::out_of_range& e) {
90417       {
90418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90419       };
90420     } catch (std::exception& e) {
90421       {
90422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90423       };
90424     } catch (Dali::DaliException e) {
90425       {
90426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90427       };
90428     } catch (...) {
90429       {
90430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90431       };
90432     }
90433   }
90434
90435   jresult = (void *)result;
90436   return jresult;
90437 }
90438
90439
90440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
90441   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90442
90443   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90444   {
90445     try {
90446       delete arg1;
90447     } catch (std::out_of_range& e) {
90448       {
90449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90450       };
90451     } catch (std::exception& e) {
90452       {
90453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90454       };
90455     } catch (Dali::DaliException e) {
90456       {
90457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90458       };
90459     } catch (...) {
90460       {
90461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90462       };
90463     }
90464   }
90465
90466 }
90467
90468
90469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
90470   unsigned int jresult ;
90471   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90472   bool result;
90473
90474   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90475   {
90476     try {
90477       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90478     } catch (std::out_of_range& e) {
90479       {
90480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90481       };
90482     } catch (std::exception& e) {
90483       {
90484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90485       };
90486     } catch (Dali::DaliException e) {
90487       {
90488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90489       };
90490     } catch (...) {
90491       {
90492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90493       };
90494     }
90495   }
90496
90497   jresult = result;
90498   return jresult;
90499 }
90500
90501
90502 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
90503   unsigned long jresult ;
90504   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90505   std::size_t result;
90506
90507   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90508   {
90509     try {
90510       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90511     } catch (std::out_of_range& e) {
90512       {
90513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90514       };
90515     } catch (std::exception& e) {
90516       {
90517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90518       };
90519     } catch (Dali::DaliException e) {
90520       {
90521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90522       };
90523     } catch (...) {
90524       {
90525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90526       };
90527     }
90528   }
90529
90530   jresult = (unsigned long)result;
90531   return jresult;
90532 }
90533
90534
90535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
90536   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90537   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90538
90539   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90540   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90541   {
90542     try {
90543       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
90544     } catch (std::out_of_range& e) {
90545       {
90546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90547       };
90548     } catch (std::exception& e) {
90549       {
90550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90551       };
90552     } catch (Dali::DaliException e) {
90553       {
90554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90555       };
90556     } catch (...) {
90557       {
90558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90559       };
90560     }
90561   }
90562
90563 }
90564
90565
90566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90567   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90568   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90569
90570   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90571   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90572   {
90573     try {
90574       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90575     } catch (std::out_of_range& e) {
90576       {
90577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90578       };
90579     } catch (std::exception& e) {
90580       {
90581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90582       };
90583     } catch (Dali::DaliException e) {
90584       {
90585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90586       };
90587     } catch (...) {
90588       {
90589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90590       };
90591     }
90592   }
90593
90594 }
90595
90596
90597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
90598   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90599   Dali::Actor arg2 ;
90600   bool arg3 ;
90601   Dali::Actor *argp2 ;
90602
90603   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90604   argp2 = (Dali::Actor *)jarg2;
90605   if (!argp2) {
90606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90607     return ;
90608   }
90609   arg2 = *argp2;
90610   arg3 = jarg3 ? true : false;
90611   {
90612     try {
90613       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
90614     } catch (std::out_of_range& e) {
90615       {
90616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90617       };
90618     } catch (std::exception& e) {
90619       {
90620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90621       };
90622     } catch (Dali::DaliException e) {
90623       {
90624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90625       };
90626     } catch (...) {
90627       {
90628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90629       };
90630     }
90631   }
90632
90633 }
90634
90635
90636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
90637   void * jresult ;
90638   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
90639
90640   {
90641     try {
90642       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
90643     } catch (std::out_of_range& e) {
90644       {
90645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90646       };
90647     } catch (std::exception& e) {
90648       {
90649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90650       };
90651     } catch (Dali::DaliException e) {
90652       {
90653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90654       };
90655     } catch (...) {
90656       {
90657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90658       };
90659     }
90660   }
90661
90662   jresult = (void *)result;
90663   return jresult;
90664 }
90665
90666
90667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
90668   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90669
90670   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90671   {
90672     try {
90673       delete arg1;
90674     } catch (std::out_of_range& e) {
90675       {
90676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90677       };
90678     } catch (std::exception& e) {
90679       {
90680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90681       };
90682     } catch (Dali::DaliException e) {
90683       {
90684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90685       };
90686     } catch (...) {
90687       {
90688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90689       };
90690     }
90691   }
90692
90693 }
90694
90695
90696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
90697   unsigned int jresult ;
90698   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90699   bool result;
90700
90701   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90702   {
90703     try {
90704       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);
90705     } catch (std::out_of_range& e) {
90706       {
90707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90708       };
90709     } catch (std::exception& e) {
90710       {
90711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90712       };
90713     } catch (Dali::DaliException e) {
90714       {
90715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90716       };
90717     } catch (...) {
90718       {
90719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90720       };
90721     }
90722   }
90723
90724   jresult = result;
90725   return jresult;
90726 }
90727
90728
90729 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
90730   unsigned long jresult ;
90731   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90732   std::size_t result;
90733
90734   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90735   {
90736     try {
90737       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);
90738     } catch (std::out_of_range& e) {
90739       {
90740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90741       };
90742     } catch (std::exception& e) {
90743       {
90744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90745       };
90746     } catch (Dali::DaliException e) {
90747       {
90748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90749       };
90750     } catch (...) {
90751       {
90752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90753       };
90754     }
90755   }
90756
90757   jresult = (unsigned long)result;
90758   return jresult;
90759 }
90760
90761
90762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
90763   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90764   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90765
90766   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90767   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90768   {
90769     try {
90770       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
90771     } catch (std::out_of_range& e) {
90772       {
90773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90774       };
90775     } catch (std::exception& e) {
90776       {
90777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90778       };
90779     } catch (Dali::DaliException e) {
90780       {
90781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90782       };
90783     } catch (...) {
90784       {
90785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90786       };
90787     }
90788   }
90789
90790 }
90791
90792
90793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90794   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90795   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90796
90797   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90798   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90799   {
90800     try {
90801       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
90802     } catch (std::out_of_range& e) {
90803       {
90804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90805       };
90806     } catch (std::exception& e) {
90807       {
90808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90809       };
90810     } catch (Dali::DaliException e) {
90811       {
90812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90813       };
90814     } catch (...) {
90815       {
90816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90817       };
90818     }
90819   }
90820
90821 }
90822
90823
90824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90825   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90826   Dali::Toolkit::StyleManager arg2 ;
90827   Dali::StyleChange::Type arg3 ;
90828   Dali::Toolkit::StyleManager *argp2 ;
90829
90830   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90831   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
90832   if (!argp2) {
90833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
90834     return ;
90835   }
90836   arg2 = *argp2;
90837   arg3 = (Dali::StyleChange::Type)jarg3;
90838   {
90839     try {
90840       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
90841     } catch (std::out_of_range& e) {
90842       {
90843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90844       };
90845     } catch (std::exception& e) {
90846       {
90847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90848       };
90849     } catch (Dali::DaliException e) {
90850       {
90851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90852       };
90853     } catch (...) {
90854       {
90855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90856       };
90857     }
90858   }
90859
90860 }
90861
90862
90863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
90864   void * jresult ;
90865   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
90866
90867   {
90868     try {
90869       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
90870     } catch (std::out_of_range& e) {
90871       {
90872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90873       };
90874     } catch (std::exception& e) {
90875       {
90876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90877       };
90878     } catch (Dali::DaliException e) {
90879       {
90880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90881       };
90882     } catch (...) {
90883       {
90884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90885       };
90886     }
90887   }
90888
90889   jresult = (void *)result;
90890   return jresult;
90891 }
90892
90893
90894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
90895   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90896
90897   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90898   {
90899     try {
90900       delete arg1;
90901     } catch (std::out_of_range& e) {
90902       {
90903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90904       };
90905     } catch (std::exception& e) {
90906       {
90907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90908       };
90909     } catch (Dali::DaliException e) {
90910       {
90911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90912       };
90913     } catch (...) {
90914       {
90915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90916       };
90917     }
90918   }
90919
90920 }
90921
90922
90923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
90924   unsigned int jresult ;
90925   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90926   bool result;
90927
90928   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90929   {
90930     try {
90931       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
90932     } catch (std::out_of_range& e) {
90933       {
90934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90935       };
90936     } catch (std::exception& e) {
90937       {
90938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90939       };
90940     } catch (Dali::DaliException e) {
90941       {
90942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90943       };
90944     } catch (...) {
90945       {
90946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90947       };
90948     }
90949   }
90950
90951   jresult = result;
90952   return jresult;
90953 }
90954
90955
90956 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
90957   unsigned long jresult ;
90958   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90959   std::size_t result;
90960
90961   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90962   {
90963     try {
90964       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
90965     } catch (std::out_of_range& e) {
90966       {
90967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90968       };
90969     } catch (std::exception& e) {
90970       {
90971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90972       };
90973     } catch (Dali::DaliException e) {
90974       {
90975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90976       };
90977     } catch (...) {
90978       {
90979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90980       };
90981     }
90982   }
90983
90984   jresult = (unsigned long)result;
90985   return jresult;
90986 }
90987
90988
90989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
90990   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90991   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
90992
90993   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90994   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
90995   {
90996     try {
90997       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
90998     } catch (std::out_of_range& e) {
90999       {
91000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91001       };
91002     } catch (std::exception& e) {
91003       {
91004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91005       };
91006     } catch (Dali::DaliException e) {
91007       {
91008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91009       };
91010     } catch (...) {
91011       {
91012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91013       };
91014     }
91015   }
91016
91017 }
91018
91019
91020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
91021   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91022   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91023
91024   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91025   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91026   {
91027     try {
91028       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
91029     } catch (std::out_of_range& e) {
91030       {
91031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91032       };
91033     } catch (std::exception& e) {
91034       {
91035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91036       };
91037     } catch (Dali::DaliException e) {
91038       {
91039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91040       };
91041     } catch (...) {
91042       {
91043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91044       };
91045     }
91046   }
91047
91048 }
91049
91050
91051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
91052   unsigned int jresult ;
91053   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91054   Dali::Toolkit::Button arg2 ;
91055   Dali::Toolkit::Button *argp2 ;
91056   bool result;
91057
91058   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91059   argp2 = (Dali::Toolkit::Button *)jarg2;
91060   if (!argp2) {
91061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
91062     return 0;
91063   }
91064   arg2 = *argp2;
91065   {
91066     try {
91067       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
91068     } catch (std::out_of_range& e) {
91069       {
91070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91071       };
91072     } catch (std::exception& e) {
91073       {
91074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91075       };
91076     } catch (Dali::DaliException e) {
91077       {
91078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91079       };
91080     } catch (...) {
91081       {
91082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91083       };
91084     }
91085   }
91086
91087   jresult = result;
91088   return jresult;
91089 }
91090
91091
91092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
91093   void * jresult ;
91094   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
91095
91096   {
91097     try {
91098       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
91099     } catch (std::out_of_range& e) {
91100       {
91101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91102       };
91103     } catch (std::exception& e) {
91104       {
91105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91106       };
91107     } catch (Dali::DaliException e) {
91108       {
91109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91110       };
91111     } catch (...) {
91112       {
91113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91114       };
91115     }
91116   }
91117
91118   jresult = (void *)result;
91119   return jresult;
91120 }
91121
91122
91123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
91124   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91125
91126   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91127   {
91128     try {
91129       delete arg1;
91130     } catch (std::out_of_range& e) {
91131       {
91132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91133       };
91134     } catch (std::exception& e) {
91135       {
91136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91137       };
91138     } catch (Dali::DaliException e) {
91139       {
91140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91141       };
91142     } catch (...) {
91143       {
91144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91145       };
91146     }
91147   }
91148
91149 }
91150
91151
91152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
91153   unsigned int jresult ;
91154   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91155   bool result;
91156
91157   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91158   {
91159     try {
91160       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91161     } catch (std::out_of_range& e) {
91162       {
91163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91164       };
91165     } catch (std::exception& e) {
91166       {
91167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91168       };
91169     } catch (Dali::DaliException e) {
91170       {
91171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91172       };
91173     } catch (...) {
91174       {
91175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91176       };
91177     }
91178   }
91179
91180   jresult = result;
91181   return jresult;
91182 }
91183
91184
91185 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
91186   unsigned long jresult ;
91187   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91188   std::size_t result;
91189
91190   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91191   {
91192     try {
91193       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91194     } catch (std::out_of_range& e) {
91195       {
91196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91197       };
91198     } catch (std::exception& e) {
91199       {
91200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91201       };
91202     } catch (Dali::DaliException e) {
91203       {
91204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91205       };
91206     } catch (...) {
91207       {
91208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91209       };
91210     }
91211   }
91212
91213   jresult = (unsigned long)result;
91214   return jresult;
91215 }
91216
91217
91218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
91219   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91220   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91221
91222   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91223   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91224   {
91225     try {
91226       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
91227     } catch (std::out_of_range& e) {
91228       {
91229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91230       };
91231     } catch (std::exception& e) {
91232       {
91233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91234       };
91235     } catch (Dali::DaliException e) {
91236       {
91237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91238       };
91239     } catch (...) {
91240       {
91241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91242       };
91243     }
91244   }
91245
91246 }
91247
91248
91249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
91250   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91251   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91252
91253   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91254   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91255   {
91256     try {
91257       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
91258     } catch (std::out_of_range& e) {
91259       {
91260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91261       };
91262     } catch (std::exception& e) {
91263       {
91264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91265       };
91266     } catch (Dali::DaliException e) {
91267       {
91268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91269       };
91270     } catch (...) {
91271       {
91272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91273       };
91274     }
91275   }
91276
91277 }
91278
91279
91280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
91281   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91282   Dali::Toolkit::GaussianBlurView arg2 ;
91283   Dali::Toolkit::GaussianBlurView *argp2 ;
91284
91285   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91286   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
91287   if (!argp2) {
91288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
91289     return ;
91290   }
91291   arg2 = *argp2;
91292   {
91293     try {
91294       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
91295     } catch (std::out_of_range& e) {
91296       {
91297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91298       };
91299     } catch (std::exception& e) {
91300       {
91301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91302       };
91303     } catch (Dali::DaliException e) {
91304       {
91305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91306       };
91307     } catch (...) {
91308       {
91309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91310       };
91311     }
91312   }
91313
91314 }
91315
91316
91317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
91318   void * jresult ;
91319   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
91320
91321   {
91322     try {
91323       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
91324     } catch (std::out_of_range& e) {
91325       {
91326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91327       };
91328     } catch (std::exception& e) {
91329       {
91330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91331       };
91332     } catch (Dali::DaliException e) {
91333       {
91334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91335       };
91336     } catch (...) {
91337       {
91338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91339       };
91340     }
91341   }
91342
91343   jresult = (void *)result;
91344   return jresult;
91345 }
91346
91347
91348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
91349   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91350
91351   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91352   {
91353     try {
91354       delete arg1;
91355     } catch (std::out_of_range& e) {
91356       {
91357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91358       };
91359     } catch (std::exception& e) {
91360       {
91361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91362       };
91363     } catch (Dali::DaliException e) {
91364       {
91365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91366       };
91367     } catch (...) {
91368       {
91369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91370       };
91371     }
91372   }
91373
91374 }
91375
91376
91377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
91378   unsigned int jresult ;
91379   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91380   bool result;
91381
91382   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91383   {
91384     try {
91385       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);
91386     } catch (std::out_of_range& e) {
91387       {
91388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91389       };
91390     } catch (std::exception& e) {
91391       {
91392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91393       };
91394     } catch (Dali::DaliException e) {
91395       {
91396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91397       };
91398     } catch (...) {
91399       {
91400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91401       };
91402     }
91403   }
91404
91405   jresult = result;
91406   return jresult;
91407 }
91408
91409
91410 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
91411   unsigned long jresult ;
91412   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91413   std::size_t result;
91414
91415   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91416   {
91417     try {
91418       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);
91419     } catch (std::out_of_range& e) {
91420       {
91421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91422       };
91423     } catch (std::exception& e) {
91424       {
91425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91426       };
91427     } catch (Dali::DaliException e) {
91428       {
91429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91430       };
91431     } catch (...) {
91432       {
91433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91434       };
91435     }
91436   }
91437
91438   jresult = (unsigned long)result;
91439   return jresult;
91440 }
91441
91442
91443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
91444   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91445   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91446
91447   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91448   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91449   {
91450     try {
91451       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
91452     } catch (std::out_of_range& e) {
91453       {
91454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91455       };
91456     } catch (std::exception& e) {
91457       {
91458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91459       };
91460     } catch (Dali::DaliException e) {
91461       {
91462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91463       };
91464     } catch (...) {
91465       {
91466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91467       };
91468     }
91469   }
91470
91471 }
91472
91473
91474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
91475   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91476   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91477
91478   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91479   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91480   {
91481     try {
91482       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
91483     } catch (std::out_of_range& e) {
91484       {
91485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91486       };
91487     } catch (std::exception& e) {
91488       {
91489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91490       };
91491     } catch (Dali::DaliException e) {
91492       {
91493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91494       };
91495     } catch (...) {
91496       {
91497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91498       };
91499     }
91500   }
91501
91502 }
91503
91504
91505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
91506   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91507   Dali::Toolkit::PageTurnView arg2 ;
91508   unsigned int arg3 ;
91509   bool arg4 ;
91510   Dali::Toolkit::PageTurnView *argp2 ;
91511
91512   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91513   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
91514   if (!argp2) {
91515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
91516     return ;
91517   }
91518   arg2 = *argp2;
91519   arg3 = (unsigned int)jarg3;
91520   arg4 = jarg4 ? true : false;
91521   {
91522     try {
91523       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
91524     } catch (std::out_of_range& e) {
91525       {
91526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91527       };
91528     } catch (std::exception& e) {
91529       {
91530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91531       };
91532     } catch (Dali::DaliException e) {
91533       {
91534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91535       };
91536     } catch (...) {
91537       {
91538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91539       };
91540     }
91541   }
91542
91543 }
91544
91545
91546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
91547   void * jresult ;
91548   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
91549
91550   {
91551     try {
91552       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
91553     } catch (std::out_of_range& e) {
91554       {
91555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91556       };
91557     } catch (std::exception& e) {
91558       {
91559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91560       };
91561     } catch (Dali::DaliException e) {
91562       {
91563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91564       };
91565     } catch (...) {
91566       {
91567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91568       };
91569     }
91570   }
91571
91572   jresult = (void *)result;
91573   return jresult;
91574 }
91575
91576
91577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
91578   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91579
91580   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91581   {
91582     try {
91583       delete arg1;
91584     } catch (std::out_of_range& e) {
91585       {
91586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91587       };
91588     } catch (std::exception& e) {
91589       {
91590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91591       };
91592     } catch (Dali::DaliException e) {
91593       {
91594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91595       };
91596     } catch (...) {
91597       {
91598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91599       };
91600     }
91601   }
91602
91603 }
91604
91605
91606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
91607   unsigned int jresult ;
91608   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91609   bool result;
91610
91611   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91612   {
91613     try {
91614       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
91615     } catch (std::out_of_range& e) {
91616       {
91617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91618       };
91619     } catch (std::exception& e) {
91620       {
91621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91622       };
91623     } catch (Dali::DaliException e) {
91624       {
91625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91626       };
91627     } catch (...) {
91628       {
91629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91630       };
91631     }
91632   }
91633
91634   jresult = result;
91635   return jresult;
91636 }
91637
91638
91639 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
91640   unsigned long jresult ;
91641   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91642   std::size_t result;
91643
91644   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91645   {
91646     try {
91647       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
91648     } catch (std::out_of_range& e) {
91649       {
91650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91651       };
91652     } catch (std::exception& e) {
91653       {
91654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91655       };
91656     } catch (Dali::DaliException e) {
91657       {
91658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91659       };
91660     } catch (...) {
91661       {
91662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91663       };
91664     }
91665   }
91666
91667   jresult = (unsigned long)result;
91668   return jresult;
91669 }
91670
91671
91672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
91673   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91674   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
91675
91676   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91677   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
91678   {
91679     try {
91680       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
91681     } catch (std::out_of_range& e) {
91682       {
91683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91684       };
91685     } catch (std::exception& e) {
91686       {
91687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91688       };
91689     } catch (Dali::DaliException e) {
91690       {
91691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91692       };
91693     } catch (...) {
91694       {
91695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91696       };
91697     }
91698   }
91699
91700 }
91701
91702
91703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
91704   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91705   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
91706
91707   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91708   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
91709   {
91710     try {
91711       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
91712     } catch (std::out_of_range& e) {
91713       {
91714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91715       };
91716     } catch (std::exception& e) {
91717       {
91718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91719       };
91720     } catch (Dali::DaliException e) {
91721       {
91722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91723       };
91724     } catch (...) {
91725       {
91726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91727       };
91728     }
91729   }
91730
91731 }
91732
91733
91734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
91735   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91736   Dali::Toolkit::PageTurnView arg2 ;
91737   Dali::Toolkit::PageTurnView *argp2 ;
91738
91739   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91740   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
91741   if (!argp2) {
91742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
91743     return ;
91744   }
91745   arg2 = *argp2;
91746   {
91747     try {
91748       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
91749     } catch (std::out_of_range& e) {
91750       {
91751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91752       };
91753     } catch (std::exception& e) {
91754       {
91755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91756       };
91757     } catch (Dali::DaliException e) {
91758       {
91759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91760       };
91761     } catch (...) {
91762       {
91763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91764       };
91765     }
91766   }
91767
91768 }
91769
91770
91771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
91772   void * jresult ;
91773   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
91774
91775   {
91776     try {
91777       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
91778     } catch (std::out_of_range& e) {
91779       {
91780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91781       };
91782     } catch (std::exception& e) {
91783       {
91784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91785       };
91786     } catch (Dali::DaliException e) {
91787       {
91788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91789       };
91790     } catch (...) {
91791       {
91792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91793       };
91794     }
91795   }
91796
91797   jresult = (void *)result;
91798   return jresult;
91799 }
91800
91801
91802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
91803   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91804
91805   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91806   {
91807     try {
91808       delete arg1;
91809     } catch (std::out_of_range& e) {
91810       {
91811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91812       };
91813     } catch (std::exception& e) {
91814       {
91815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91816       };
91817     } catch (Dali::DaliException e) {
91818       {
91819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91820       };
91821     } catch (...) {
91822       {
91823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91824       };
91825     }
91826   }
91827
91828 }
91829
91830
91831 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
91832   unsigned int jresult ;
91833   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91834   bool result;
91835
91836   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91837   {
91838     try {
91839       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);
91840     } catch (std::out_of_range& e) {
91841       {
91842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91843       };
91844     } catch (std::exception& e) {
91845       {
91846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91847       };
91848     } catch (Dali::DaliException e) {
91849       {
91850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91851       };
91852     } catch (...) {
91853       {
91854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91855       };
91856     }
91857   }
91858
91859   jresult = result;
91860   return jresult;
91861 }
91862
91863
91864 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
91865   unsigned long jresult ;
91866   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91867   std::size_t result;
91868
91869   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91870   {
91871     try {
91872       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);
91873     } catch (std::out_of_range& e) {
91874       {
91875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91876       };
91877     } catch (std::exception& e) {
91878       {
91879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91880       };
91881     } catch (Dali::DaliException e) {
91882       {
91883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91884       };
91885     } catch (...) {
91886       {
91887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91888       };
91889     }
91890   }
91891
91892   jresult = (unsigned long)result;
91893   return jresult;
91894 }
91895
91896
91897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
91898   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91899   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
91900
91901   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91902   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
91903   {
91904     try {
91905       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
91906     } catch (std::out_of_range& e) {
91907       {
91908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91909       };
91910     } catch (std::exception& e) {
91911       {
91912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91913       };
91914     } catch (Dali::DaliException e) {
91915       {
91916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91917       };
91918     } catch (...) {
91919       {
91920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91921       };
91922     }
91923   }
91924
91925 }
91926
91927
91928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91929   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91930   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
91931
91932   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91933   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
91934   {
91935     try {
91936       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
91937     } catch (std::out_of_range& e) {
91938       {
91939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91940       };
91941     } catch (std::exception& e) {
91942       {
91943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91944       };
91945     } catch (Dali::DaliException e) {
91946       {
91947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91948       };
91949     } catch (...) {
91950       {
91951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91952       };
91953     }
91954   }
91955
91956 }
91957
91958
91959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
91960   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91961   Dali::Toolkit::ProgressBar arg2 ;
91962   float arg3 ;
91963   float arg4 ;
91964   Dali::Toolkit::ProgressBar *argp2 ;
91965
91966   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91967   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
91968   if (!argp2) {
91969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
91970     return ;
91971   }
91972   arg2 = *argp2;
91973   arg3 = (float)jarg3;
91974   arg4 = (float)jarg4;
91975   {
91976     try {
91977       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
91978     } catch (std::out_of_range& e) {
91979       {
91980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91981       };
91982     } catch (std::exception& e) {
91983       {
91984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91985       };
91986     } catch (Dali::DaliException e) {
91987       {
91988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91989       };
91990     } catch (...) {
91991       {
91992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91993       };
91994     }
91995   }
91996
91997 }
91998
91999
92000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
92001   void * jresult ;
92002   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
92003
92004   {
92005     try {
92006       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
92007     } catch (std::out_of_range& e) {
92008       {
92009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92010       };
92011     } catch (std::exception& e) {
92012       {
92013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92014       };
92015     } catch (Dali::DaliException e) {
92016       {
92017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92018       };
92019     } catch (...) {
92020       {
92021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92022       };
92023     }
92024   }
92025
92026   jresult = (void *)result;
92027   return jresult;
92028 }
92029
92030
92031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
92032   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92033
92034   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92035   {
92036     try {
92037       delete arg1;
92038     } catch (std::out_of_range& e) {
92039       {
92040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92041       };
92042     } catch (std::exception& e) {
92043       {
92044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92045       };
92046     } catch (Dali::DaliException e) {
92047       {
92048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92049       };
92050     } catch (...) {
92051       {
92052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92053       };
92054     }
92055   }
92056
92057 }
92058
92059
92060 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
92061   unsigned int jresult ;
92062   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92063   bool result;
92064
92065   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92066   {
92067     try {
92068       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);
92069     } catch (std::out_of_range& e) {
92070       {
92071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92072       };
92073     } catch (std::exception& e) {
92074       {
92075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92076       };
92077     } catch (Dali::DaliException e) {
92078       {
92079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92080       };
92081     } catch (...) {
92082       {
92083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92084       };
92085     }
92086   }
92087
92088   jresult = result;
92089   return jresult;
92090 }
92091
92092
92093 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
92094   unsigned long jresult ;
92095   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92096   std::size_t result;
92097
92098   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92099   {
92100     try {
92101       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);
92102     } catch (std::out_of_range& e) {
92103       {
92104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92105       };
92106     } catch (std::exception& e) {
92107       {
92108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92109       };
92110     } catch (Dali::DaliException e) {
92111       {
92112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92113       };
92114     } catch (...) {
92115       {
92116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92117       };
92118     }
92119   }
92120
92121   jresult = (unsigned long)result;
92122   return jresult;
92123 }
92124
92125
92126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
92127   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92128   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92129
92130   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92131   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92132   {
92133     try {
92134       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92135     } catch (std::out_of_range& e) {
92136       {
92137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92138       };
92139     } catch (std::exception& e) {
92140       {
92141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92142       };
92143     } catch (Dali::DaliException e) {
92144       {
92145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92146       };
92147     } catch (...) {
92148       {
92149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92150       };
92151     }
92152   }
92153
92154 }
92155
92156
92157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
92158   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92159   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92160
92161   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92162   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92163   {
92164     try {
92165       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92166     } catch (std::out_of_range& e) {
92167       {
92168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92169       };
92170     } catch (std::exception& e) {
92171       {
92172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92173       };
92174     } catch (Dali::DaliException e) {
92175       {
92176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92177       };
92178     } catch (...) {
92179       {
92180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92181       };
92182     }
92183   }
92184
92185 }
92186
92187
92188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
92189   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92190   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
92191
92192   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92193   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
92194   if (!arg2) {
92195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
92196     return ;
92197   }
92198   {
92199     try {
92200       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
92201     } catch (std::out_of_range& e) {
92202       {
92203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92204       };
92205     } catch (std::exception& e) {
92206       {
92207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92208       };
92209     } catch (Dali::DaliException e) {
92210       {
92211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92212       };
92213     } catch (...) {
92214       {
92215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92216       };
92217     }
92218   }
92219
92220 }
92221
92222
92223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
92224   void * jresult ;
92225   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
92226
92227   {
92228     try {
92229       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
92230     } catch (std::out_of_range& e) {
92231       {
92232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92233       };
92234     } catch (std::exception& e) {
92235       {
92236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92237       };
92238     } catch (Dali::DaliException e) {
92239       {
92240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92241       };
92242     } catch (...) {
92243       {
92244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92245       };
92246     }
92247   }
92248
92249   jresult = (void *)result;
92250   return jresult;
92251 }
92252
92253
92254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
92255   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92256
92257   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92258   {
92259     try {
92260       delete arg1;
92261     } catch (std::out_of_range& e) {
92262       {
92263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92264       };
92265     } catch (std::exception& e) {
92266       {
92267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92268       };
92269     } catch (Dali::DaliException e) {
92270       {
92271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92272       };
92273     } catch (...) {
92274       {
92275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92276       };
92277     }
92278   }
92279
92280 }
92281
92282
92283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
92284   unsigned int jresult ;
92285   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92286   bool result;
92287
92288   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92289   {
92290     try {
92291       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92292     } catch (std::out_of_range& e) {
92293       {
92294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92295       };
92296     } catch (std::exception& e) {
92297       {
92298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92299       };
92300     } catch (Dali::DaliException e) {
92301       {
92302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92303       };
92304     } catch (...) {
92305       {
92306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92307       };
92308     }
92309   }
92310
92311   jresult = result;
92312   return jresult;
92313 }
92314
92315
92316 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
92317   unsigned long jresult ;
92318   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92319   std::size_t result;
92320
92321   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92322   {
92323     try {
92324       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92325     } catch (std::out_of_range& e) {
92326       {
92327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92328       };
92329     } catch (std::exception& e) {
92330       {
92331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92332       };
92333     } catch (Dali::DaliException e) {
92334       {
92335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92336       };
92337     } catch (...) {
92338       {
92339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92340       };
92341     }
92342   }
92343
92344   jresult = (unsigned long)result;
92345   return jresult;
92346 }
92347
92348
92349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
92350   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92351   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92352
92353   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92354   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92355   {
92356     try {
92357       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92358     } catch (std::out_of_range& e) {
92359       {
92360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92361       };
92362     } catch (std::exception& e) {
92363       {
92364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92365       };
92366     } catch (Dali::DaliException e) {
92367       {
92368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92369       };
92370     } catch (...) {
92371       {
92372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92373       };
92374     }
92375   }
92376
92377 }
92378
92379
92380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
92381   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92382   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92383
92384   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92385   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92386   {
92387     try {
92388       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92389     } catch (std::out_of_range& e) {
92390       {
92391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92392       };
92393     } catch (std::exception& e) {
92394       {
92395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92396       };
92397     } catch (Dali::DaliException e) {
92398       {
92399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92400       };
92401     } catch (...) {
92402       {
92403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92404       };
92405     }
92406   }
92407
92408 }
92409
92410
92411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
92412   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92413   Dali::Vector2 *arg2 = 0 ;
92414
92415   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92416   arg2 = (Dali::Vector2 *)jarg2;
92417   if (!arg2) {
92418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
92419     return ;
92420   }
92421   {
92422     try {
92423       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
92424     } catch (std::out_of_range& e) {
92425       {
92426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92427       };
92428     } catch (std::exception& e) {
92429       {
92430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92431       };
92432     } catch (Dali::DaliException e) {
92433       {
92434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92435       };
92436     } catch (...) {
92437       {
92438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92439       };
92440     }
92441   }
92442
92443 }
92444
92445
92446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
92447   void * jresult ;
92448   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
92449
92450   {
92451     try {
92452       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
92453     } catch (std::out_of_range& e) {
92454       {
92455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92456       };
92457     } catch (std::exception& e) {
92458       {
92459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92460       };
92461     } catch (Dali::DaliException e) {
92462       {
92463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92464       };
92465     } catch (...) {
92466       {
92467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92468       };
92469     }
92470   }
92471
92472   jresult = (void *)result;
92473   return jresult;
92474 }
92475
92476
92477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
92478   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92479
92480   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92481   {
92482     try {
92483       delete arg1;
92484     } catch (std::out_of_range& e) {
92485       {
92486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92487       };
92488     } catch (std::exception& e) {
92489       {
92490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92491       };
92492     } catch (Dali::DaliException e) {
92493       {
92494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92495       };
92496     } catch (...) {
92497       {
92498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92499       };
92500     }
92501   }
92502
92503 }
92504
92505
92506
92507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
92508   unsigned int jresult ;
92509   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92510   bool result;
92511
92512   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92513   {
92514     try {
92515       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);
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 = result;
92536   return jresult;
92537 }
92538
92539
92540 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
92541   unsigned long jresult ;
92542   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92543   std::size_t result;
92544
92545   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92546   {
92547     try {
92548       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);
92549     } catch (std::out_of_range& e) {
92550       {
92551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92552       };
92553     } catch (std::exception& e) {
92554       {
92555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92556       };
92557     } catch (Dali::DaliException e) {
92558       {
92559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92560       };
92561     } catch (...) {
92562       {
92563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92564       };
92565     }
92566   }
92567
92568   jresult = (unsigned long)result;
92569   return jresult;
92570 }
92571
92572
92573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
92574   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92575   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92576
92577   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92578   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92579   {
92580     try {
92581       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92582     } catch (std::out_of_range& e) {
92583       {
92584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92585       };
92586     } catch (std::exception& e) {
92587       {
92588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92589       };
92590     } catch (Dali::DaliException e) {
92591       {
92592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92593       };
92594     } catch (...) {
92595       {
92596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92597       };
92598     }
92599   }
92600
92601 }
92602
92603
92604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
92605   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92606   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92607
92608   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92609   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92610   {
92611     try {
92612       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92613     } catch (std::out_of_range& e) {
92614       {
92615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92616       };
92617     } catch (std::exception& e) {
92618       {
92619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92620       };
92621     } catch (Dali::DaliException e) {
92622       {
92623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92624       };
92625     } catch (...) {
92626       {
92627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92628       };
92629     }
92630   }
92631
92632 }
92633
92634
92635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
92636   unsigned int jresult ;
92637   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92638   Dali::Toolkit::Control arg2 ;
92639   Dali::KeyEvent *arg3 = 0 ;
92640   Dali::Toolkit::Control *argp2 ;
92641   bool result;
92642
92643   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92644   argp2 = (Dali::Toolkit::Control *)jarg2;
92645   if (!argp2) {
92646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92647     return 0;
92648   }
92649   arg2 = *argp2;
92650   arg3 = (Dali::KeyEvent *)jarg3;
92651   if (!arg3) {
92652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
92653     return 0;
92654   }
92655   {
92656     try {
92657       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);
92658     } catch (std::out_of_range& e) {
92659       {
92660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92661       };
92662     } catch (std::exception& e) {
92663       {
92664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92665       };
92666     } catch (Dali::DaliException e) {
92667       {
92668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92669       };
92670     } catch (...) {
92671       {
92672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92673       };
92674     }
92675   }
92676
92677   jresult = result;
92678   return jresult;
92679 }
92680
92681
92682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
92683   void * jresult ;
92684   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
92685
92686   {
92687     try {
92688       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
92689     } catch (std::out_of_range& e) {
92690       {
92691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92692       };
92693     } catch (std::exception& e) {
92694       {
92695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92696       };
92697     } catch (Dali::DaliException e) {
92698       {
92699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92700       };
92701     } catch (...) {
92702       {
92703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92704       };
92705     }
92706   }
92707
92708   jresult = (void *)result;
92709   return jresult;
92710 }
92711
92712
92713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
92714   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92715
92716   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92717   {
92718     try {
92719       delete arg1;
92720     } catch (std::out_of_range& e) {
92721       {
92722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92723       };
92724     } catch (std::exception& e) {
92725       {
92726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92727       };
92728     } catch (Dali::DaliException e) {
92729       {
92730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92731       };
92732     } catch (...) {
92733       {
92734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92735       };
92736     }
92737   }
92738
92739 }
92740
92741
92742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
92743   unsigned int jresult ;
92744   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92745   bool result;
92746
92747   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92748   {
92749     try {
92750       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92751     } catch (std::out_of_range& e) {
92752       {
92753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92754       };
92755     } catch (std::exception& e) {
92756       {
92757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92758       };
92759     } catch (Dali::DaliException e) {
92760       {
92761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92762       };
92763     } catch (...) {
92764       {
92765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92766       };
92767     }
92768   }
92769
92770   jresult = result;
92771   return jresult;
92772 }
92773
92774
92775 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
92776   unsigned long jresult ;
92777   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92778   std::size_t result;
92779
92780   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92781   {
92782     try {
92783       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92784     } catch (std::out_of_range& e) {
92785       {
92786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92787       };
92788     } catch (std::exception& e) {
92789       {
92790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92791       };
92792     } catch (Dali::DaliException e) {
92793       {
92794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92795       };
92796     } catch (...) {
92797       {
92798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92799       };
92800     }
92801   }
92802
92803   jresult = (unsigned long)result;
92804   return jresult;
92805 }
92806
92807
92808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
92809   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92810   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92811
92812   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92813   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92814   {
92815     try {
92816       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
92817     } catch (std::out_of_range& e) {
92818       {
92819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92820       };
92821     } catch (std::exception& e) {
92822       {
92823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92824       };
92825     } catch (Dali::DaliException e) {
92826       {
92827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92828       };
92829     } catch (...) {
92830       {
92831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92832       };
92833     }
92834   }
92835
92836 }
92837
92838
92839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
92840   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92841   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92842
92843   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92844   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92845   {
92846     try {
92847       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
92848     } catch (std::out_of_range& e) {
92849       {
92850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92851       };
92852     } catch (std::exception& e) {
92853       {
92854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92855       };
92856     } catch (Dali::DaliException e) {
92857       {
92858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92859       };
92860     } catch (...) {
92861       {
92862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92863       };
92864     }
92865   }
92866
92867 }
92868
92869
92870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
92871   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92872   Dali::Toolkit::Control arg2 ;
92873   Dali::Toolkit::Control *argp2 ;
92874
92875   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92876   argp2 = (Dali::Toolkit::Control *)jarg2;
92877   if (!argp2) {
92878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92879     return ;
92880   }
92881   arg2 = *argp2;
92882   {
92883     try {
92884       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
92885     } catch (std::out_of_range& e) {
92886       {
92887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92888       };
92889     } catch (std::exception& e) {
92890       {
92891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92892       };
92893     } catch (Dali::DaliException e) {
92894       {
92895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92896       };
92897     } catch (...) {
92898       {
92899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92900       };
92901     }
92902   }
92903
92904 }
92905
92906
92907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
92908   void * jresult ;
92909   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
92910
92911   {
92912     try {
92913       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
92914     } catch (std::out_of_range& e) {
92915       {
92916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92917       };
92918     } catch (std::exception& e) {
92919       {
92920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92921       };
92922     } catch (Dali::DaliException e) {
92923       {
92924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92925       };
92926     } catch (...) {
92927       {
92928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92929       };
92930     }
92931   }
92932
92933   jresult = (void *)result;
92934   return jresult;
92935 }
92936
92937
92938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
92939   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92940
92941   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92942   {
92943     try {
92944       delete arg1;
92945     } catch (std::out_of_range& e) {
92946       {
92947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92948       };
92949     } catch (std::exception& e) {
92950       {
92951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92952       };
92953     } catch (Dali::DaliException e) {
92954       {
92955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92956       };
92957     } catch (...) {
92958       {
92959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92960       };
92961     }
92962   }
92963
92964 }
92965
92966
92967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
92968   unsigned int jresult ;
92969   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
92970   bool result;
92971
92972   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
92973   {
92974     try {
92975       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
92976     } catch (std::out_of_range& e) {
92977       {
92978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92979       };
92980     } catch (std::exception& e) {
92981       {
92982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92983       };
92984     } catch (Dali::DaliException e) {
92985       {
92986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92987       };
92988     } catch (...) {
92989       {
92990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92991       };
92992     }
92993   }
92994
92995   jresult = result;
92996   return jresult;
92997 }
92998
92999
93000 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
93001   unsigned long jresult ;
93002   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93003   std::size_t result;
93004
93005   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93006   {
93007     try {
93008       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93009     } catch (std::out_of_range& e) {
93010       {
93011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93012       };
93013     } catch (std::exception& e) {
93014       {
93015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93016       };
93017     } catch (Dali::DaliException e) {
93018       {
93019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93020       };
93021     } catch (...) {
93022       {
93023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93024       };
93025     }
93026   }
93027
93028   jresult = (unsigned long)result;
93029   return jresult;
93030 }
93031
93032
93033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
93034   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93035   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93036
93037   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93038   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93039   {
93040     try {
93041       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
93042     } catch (std::out_of_range& e) {
93043       {
93044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93045       };
93046     } catch (std::exception& e) {
93047       {
93048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93049       };
93050     } catch (Dali::DaliException e) {
93051       {
93052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93053       };
93054     } catch (...) {
93055       {
93056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93057       };
93058     }
93059   }
93060
93061 }
93062
93063
93064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
93065   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93066   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93067
93068   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93069   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93070   {
93071     try {
93072       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
93073     } catch (std::out_of_range& e) {
93074       {
93075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93076       };
93077     } catch (std::exception& e) {
93078       {
93079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93080       };
93081     } catch (Dali::DaliException e) {
93082       {
93083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93084       };
93085     } catch (...) {
93086       {
93087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93088       };
93089     }
93090   }
93091
93092 }
93093
93094
93095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
93096   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93097   Dali::Toolkit::VideoView *arg2 = 0 ;
93098
93099   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93100   arg2 = (Dali::Toolkit::VideoView *)jarg2;
93101   if (!arg2) {
93102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
93103     return ;
93104   }
93105   {
93106     try {
93107       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
93108     } catch (std::out_of_range& e) {
93109       {
93110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93111       };
93112     } catch (std::exception& e) {
93113       {
93114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93115       };
93116     } catch (Dali::DaliException e) {
93117       {
93118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93119       };
93120     } catch (...) {
93121       {
93122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93123       };
93124     }
93125   }
93126
93127 }
93128
93129
93130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
93131   void * jresult ;
93132   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
93133
93134   {
93135     try {
93136       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
93137     } catch (std::out_of_range& e) {
93138       {
93139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93140       };
93141     } catch (std::exception& e) {
93142       {
93143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93144       };
93145     } catch (Dali::DaliException e) {
93146       {
93147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93148       };
93149     } catch (...) {
93150       {
93151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93152       };
93153     }
93154   }
93155
93156   jresult = (void *)result;
93157   return jresult;
93158 }
93159
93160
93161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
93162   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93163
93164   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93165   {
93166     try {
93167       delete arg1;
93168     } catch (std::out_of_range& e) {
93169       {
93170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93171       };
93172     } catch (std::exception& e) {
93173       {
93174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93175       };
93176     } catch (Dali::DaliException e) {
93177       {
93178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93179       };
93180     } catch (...) {
93181       {
93182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93183       };
93184     }
93185   }
93186
93187 }
93188
93189
93190 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
93191   unsigned int jresult ;
93192   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93193   bool result;
93194
93195   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93196   {
93197     try {
93198       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93199     } catch (std::out_of_range& e) {
93200       {
93201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93202       };
93203     } catch (std::exception& e) {
93204       {
93205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93206       };
93207     } catch (Dali::DaliException e) {
93208       {
93209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93210       };
93211     } catch (...) {
93212       {
93213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93214       };
93215     }
93216   }
93217
93218   jresult = result;
93219   return jresult;
93220 }
93221
93222
93223 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
93224   unsigned long jresult ;
93225   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93226   std::size_t result;
93227
93228   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93229   {
93230     try {
93231       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93232     } catch (std::out_of_range& e) {
93233       {
93234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93235       };
93236     } catch (std::exception& e) {
93237       {
93238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93239       };
93240     } catch (Dali::DaliException e) {
93241       {
93242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93243       };
93244     } catch (...) {
93245       {
93246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93247       };
93248     }
93249   }
93250
93251   jresult = (unsigned long)result;
93252   return jresult;
93253 }
93254
93255
93256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
93257   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93258   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93259
93260   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93261   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93262   {
93263     try {
93264       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
93265     } catch (std::out_of_range& e) {
93266       {
93267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93268       };
93269     } catch (std::exception& e) {
93270       {
93271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93272       };
93273     } catch (Dali::DaliException e) {
93274       {
93275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93276       };
93277     } catch (...) {
93278       {
93279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93280       };
93281     }
93282   }
93283
93284 }
93285
93286
93287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
93288   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93289   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93290
93291   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93292   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93293   {
93294     try {
93295       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
93296     } catch (std::out_of_range& e) {
93297       {
93298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93299       };
93300     } catch (std::exception& e) {
93301       {
93302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93303       };
93304     } catch (Dali::DaliException e) {
93305       {
93306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93307       };
93308     } catch (...) {
93309       {
93310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93311       };
93312     }
93313   }
93314
93315 }
93316
93317
93318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
93319   unsigned int jresult ;
93320   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93321   Dali::Toolkit::Slider arg2 ;
93322   float arg3 ;
93323   Dali::Toolkit::Slider *argp2 ;
93324   bool result;
93325
93326   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93327   argp2 = (Dali::Toolkit::Slider *)jarg2;
93328   if (!argp2) {
93329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93330     return 0;
93331   }
93332   arg2 = *argp2;
93333   arg3 = (float)jarg3;
93334   {
93335     try {
93336       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
93337     } catch (std::out_of_range& e) {
93338       {
93339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93340       };
93341     } catch (std::exception& e) {
93342       {
93343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93344       };
93345     } catch (Dali::DaliException e) {
93346       {
93347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93348       };
93349     } catch (...) {
93350       {
93351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93352       };
93353     }
93354   }
93355
93356   jresult = result;
93357   return jresult;
93358 }
93359
93360
93361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
93362   void * jresult ;
93363   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
93364
93365   {
93366     try {
93367       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
93368     } catch (std::out_of_range& e) {
93369       {
93370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93371       };
93372     } catch (std::exception& e) {
93373       {
93374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93375       };
93376     } catch (Dali::DaliException e) {
93377       {
93378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93379       };
93380     } catch (...) {
93381       {
93382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93383       };
93384     }
93385   }
93386
93387   jresult = (void *)result;
93388   return jresult;
93389 }
93390
93391
93392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
93393   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93394
93395   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93396   {
93397     try {
93398       delete arg1;
93399     } catch (std::out_of_range& e) {
93400       {
93401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93402       };
93403     } catch (std::exception& e) {
93404       {
93405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93406       };
93407     } catch (Dali::DaliException e) {
93408       {
93409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93410       };
93411     } catch (...) {
93412       {
93413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93414       };
93415     }
93416   }
93417
93418 }
93419
93420
93421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
93422   unsigned int jresult ;
93423   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93424   bool result;
93425
93426   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93427   {
93428     try {
93429       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93430     } catch (std::out_of_range& e) {
93431       {
93432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93433       };
93434     } catch (std::exception& e) {
93435       {
93436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93437       };
93438     } catch (Dali::DaliException e) {
93439       {
93440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93441       };
93442     } catch (...) {
93443       {
93444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93445       };
93446     }
93447   }
93448
93449   jresult = result;
93450   return jresult;
93451 }
93452
93453
93454 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
93455   unsigned long jresult ;
93456   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93457   std::size_t result;
93458
93459   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93460   {
93461     try {
93462       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93463     } catch (std::out_of_range& e) {
93464       {
93465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93466       };
93467     } catch (std::exception& e) {
93468       {
93469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93470       };
93471     } catch (Dali::DaliException e) {
93472       {
93473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93474       };
93475     } catch (...) {
93476       {
93477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93478       };
93479     }
93480   }
93481
93482   jresult = (unsigned long)result;
93483   return jresult;
93484 }
93485
93486
93487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
93488   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93489   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93490
93491   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93492   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93493   {
93494     try {
93495       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
93496     } catch (std::out_of_range& e) {
93497       {
93498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93499       };
93500     } catch (std::exception& e) {
93501       {
93502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93503       };
93504     } catch (Dali::DaliException e) {
93505       {
93506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93507       };
93508     } catch (...) {
93509       {
93510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93511       };
93512     }
93513   }
93514
93515 }
93516
93517
93518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
93519   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93520   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93521
93522   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93523   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93524   {
93525     try {
93526       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
93527     } catch (std::out_of_range& e) {
93528       {
93529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93530       };
93531     } catch (std::exception& e) {
93532       {
93533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93534       };
93535     } catch (Dali::DaliException e) {
93536       {
93537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93538       };
93539     } catch (...) {
93540       {
93541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93542       };
93543     }
93544   }
93545
93546 }
93547
93548
93549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
93550   unsigned int jresult ;
93551   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93552   Dali::Toolkit::Slider arg2 ;
93553   int arg3 ;
93554   Dali::Toolkit::Slider *argp2 ;
93555   bool result;
93556
93557   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93558   argp2 = (Dali::Toolkit::Slider *)jarg2;
93559   if (!argp2) {
93560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93561     return 0;
93562   }
93563   arg2 = *argp2;
93564   arg3 = (int)jarg3;
93565   {
93566     try {
93567       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
93568     } catch (std::out_of_range& e) {
93569       {
93570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93571       };
93572     } catch (std::exception& e) {
93573       {
93574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93575       };
93576     } catch (Dali::DaliException e) {
93577       {
93578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93579       };
93580     } catch (...) {
93581       {
93582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93583       };
93584     }
93585   }
93586
93587   jresult = result;
93588   return jresult;
93589 }
93590
93591
93592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
93593   void * jresult ;
93594   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
93595
93596   {
93597     try {
93598       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
93599     } catch (std::out_of_range& e) {
93600       {
93601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93602       };
93603     } catch (std::exception& e) {
93604       {
93605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93606       };
93607     } catch (Dali::DaliException e) {
93608       {
93609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93610       };
93611     } catch (...) {
93612       {
93613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93614       };
93615     }
93616   }
93617
93618   jresult = (void *)result;
93619   return jresult;
93620 }
93621
93622
93623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
93624   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93625
93626   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93627   {
93628     try {
93629       delete arg1;
93630     } catch (std::out_of_range& e) {
93631       {
93632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93633       };
93634     } catch (std::exception& e) {
93635       {
93636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93637       };
93638     } catch (Dali::DaliException e) {
93639       {
93640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93641       };
93642     } catch (...) {
93643       {
93644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93645       };
93646     }
93647   }
93648
93649 }
93650
93651
93652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
93653   void * jresult ;
93654   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93655
93656   {
93657     try {
93658       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
93659     } catch (std::out_of_range& e) {
93660       {
93661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93662       };
93663     } catch (std::exception& e) {
93664       {
93665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93666       };
93667     } catch (Dali::DaliException e) {
93668       {
93669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93670       };
93671     } catch (...) {
93672       {
93673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93674       };
93675     }
93676   }
93677
93678   jresult = (void *)result;
93679   return jresult;
93680 }
93681
93682
93683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
93684   void * jresult ;
93685   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
93686   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93687
93688   arg1 = (Dali::Toolkit::Ruler *)jarg1;
93689   {
93690     try {
93691       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
93692     } catch (std::out_of_range& e) {
93693       {
93694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93695       };
93696     } catch (std::exception& e) {
93697       {
93698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93699       };
93700     } catch (Dali::DaliException e) {
93701       {
93702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93703       };
93704     } catch (...) {
93705       {
93706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93707       };
93708     }
93709   }
93710
93711   jresult = (void *)result;
93712   return jresult;
93713 }
93714
93715
93716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
93717   void * jresult ;
93718   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
93719   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93720
93721   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93722   if (!arg1) {
93723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93724     return 0;
93725   }
93726   {
93727     try {
93728       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
93729     } catch (std::out_of_range& e) {
93730       {
93731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93732       };
93733     } catch (std::exception& e) {
93734       {
93735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93736       };
93737     } catch (Dali::DaliException e) {
93738       {
93739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93740       };
93741     } catch (...) {
93742       {
93743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93744       };
93745     }
93746   }
93747
93748   jresult = (void *)result;
93749   return jresult;
93750 }
93751
93752
93753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
93754   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93755
93756   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93757   {
93758     try {
93759       delete arg1;
93760     } catch (std::out_of_range& e) {
93761       {
93762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93763       };
93764     } catch (std::exception& e) {
93765       {
93766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93767       };
93768     } catch (Dali::DaliException e) {
93769       {
93770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93771       };
93772     } catch (...) {
93773       {
93774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93775       };
93776     }
93777   }
93778
93779 }
93780
93781
93782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
93783   void * jresult ;
93784   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93785   Dali::Toolkit::Ruler *result = 0 ;
93786
93787   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93788   {
93789     try {
93790       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
93791     } catch (std::out_of_range& e) {
93792       {
93793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93794       };
93795     } catch (std::exception& e) {
93796       {
93797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93798       };
93799     } catch (Dali::DaliException e) {
93800       {
93801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93802       };
93803     } catch (...) {
93804       {
93805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93806       };
93807     }
93808   }
93809
93810   jresult = (void *)result;
93811   return jresult;
93812 }
93813
93814
93815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
93816   void * jresult ;
93817   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93818   Dali::Toolkit::Ruler *result = 0 ;
93819
93820   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93821   {
93822     try {
93823       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
93824     } catch (std::out_of_range& e) {
93825       {
93826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93827       };
93828     } catch (std::exception& e) {
93829       {
93830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93831       };
93832     } catch (Dali::DaliException e) {
93833       {
93834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93835       };
93836     } catch (...) {
93837       {
93838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93839       };
93840     }
93841   }
93842
93843   jresult = (void *)result;
93844   return jresult;
93845 }
93846
93847
93848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
93849   void * jresult ;
93850   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93851   Dali::Toolkit::Ruler *result = 0 ;
93852
93853   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93854   {
93855     try {
93856       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
93857     } catch (std::out_of_range& e) {
93858       {
93859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93860       };
93861     } catch (std::exception& e) {
93862       {
93863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93864       };
93865     } catch (Dali::DaliException e) {
93866       {
93867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93868       };
93869     } catch (...) {
93870       {
93871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93872       };
93873     }
93874   }
93875
93876   jresult = (void *)result;
93877   return jresult;
93878 }
93879
93880
93881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
93882   void * jresult ;
93883   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93884   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
93885   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93886
93887   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93888   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
93889   if (!arg2) {
93890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93891     return 0;
93892   }
93893   {
93894     try {
93895       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
93896     } catch (std::out_of_range& e) {
93897       {
93898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93899       };
93900     } catch (std::exception& e) {
93901       {
93902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93903       };
93904     } catch (Dali::DaliException e) {
93905       {
93906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93907       };
93908     } catch (...) {
93909       {
93910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93911       };
93912     }
93913   }
93914
93915   jresult = (void *)result;
93916   return jresult;
93917 }
93918
93919
93920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
93921   void * jresult ;
93922   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93923   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
93924   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93925
93926   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93927   arg2 = (Dali::Toolkit::Ruler *)jarg2;
93928   {
93929     try {
93930       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
93931     } catch (std::out_of_range& e) {
93932       {
93933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93934       };
93935     } catch (std::exception& e) {
93936       {
93937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93938       };
93939     } catch (Dali::DaliException e) {
93940       {
93941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93942       };
93943     } catch (...) {
93944       {
93945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93946       };
93947     }
93948   }
93949
93950   jresult = (void *)result;
93951   return jresult;
93952 }
93953
93954
93955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
93956   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93957
93958   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93959   {
93960     try {
93961       (arg1)->Reset();
93962     } catch (std::out_of_range& e) {
93963       {
93964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93965       };
93966     } catch (std::exception& e) {
93967       {
93968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93969       };
93970     } catch (Dali::DaliException e) {
93971       {
93972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93973       };
93974     } catch (...) {
93975       {
93976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93977       };
93978     }
93979   }
93980
93981 }
93982
93983
93984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
93985   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93986   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
93987
93988   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93989   arg2 = (Dali::Toolkit::Ruler *)jarg2;
93990   {
93991     try {
93992       (arg1)->Reset(arg2);
93993     } catch (std::out_of_range& e) {
93994       {
93995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93996       };
93997     } catch (std::exception& e) {
93998       {
93999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94000       };
94001     } catch (Dali::DaliException e) {
94002       {
94003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94004       };
94005     } catch (...) {
94006       {
94007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94008       };
94009     }
94010   }
94011
94012 }
94013
94014
94015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
94016   void * jresult ;
94017   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94018   Dali::Toolkit::Ruler *result = 0 ;
94019
94020   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94021   {
94022     try {
94023       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
94024     } catch (std::out_of_range& e) {
94025       {
94026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94027       };
94028     } catch (std::exception& e) {
94029       {
94030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94031       };
94032     } catch (Dali::DaliException e) {
94033       {
94034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94035       };
94036     } catch (...) {
94037       {
94038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94039       };
94040     }
94041   }
94042
94043   jresult = (void *)result;
94044   return jresult;
94045 }
94046
94047
94048 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
94049   float jresult ;
94050   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94051   float arg2 ;
94052   float arg3 ;
94053   float result;
94054
94055   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94056   arg2 = (float)jarg2;
94057   arg3 = (float)jarg3;
94058   {
94059     try {
94060       result = (float)(*arg1)->Snap(arg2,arg3);
94061     } catch (std::out_of_range& e) {
94062       {
94063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94064       };
94065     } catch (std::exception& e) {
94066       {
94067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94068       };
94069     } catch (Dali::DaliException e) {
94070       {
94071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94072       };
94073     } catch (...) {
94074       {
94075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94076       };
94077     }
94078   }
94079
94080   jresult = result;
94081   return jresult;
94082 }
94083
94084
94085 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
94086   float jresult ;
94087   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94088   float arg2 ;
94089   float result;
94090
94091   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94092   arg2 = (float)jarg2;
94093   {
94094     try {
94095       result = (float)(*arg1)->Snap(arg2);
94096     } catch (std::out_of_range& e) {
94097       {
94098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94099       };
94100     } catch (std::exception& e) {
94101       {
94102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94103       };
94104     } catch (Dali::DaliException e) {
94105       {
94106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94107       };
94108     } catch (...) {
94109       {
94110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94111       };
94112     }
94113   }
94114
94115   jresult = result;
94116   return jresult;
94117 }
94118
94119
94120 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
94121   float jresult ;
94122   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94123   unsigned int arg2 ;
94124   unsigned int *arg3 = 0 ;
94125   bool arg4 ;
94126   float result;
94127
94128   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94129   arg2 = (unsigned int)jarg2;
94130   arg3 = (unsigned int *)jarg3;
94131   arg4 = jarg4 ? true : false;
94132   {
94133     try {
94134       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
94135     } catch (std::out_of_range& e) {
94136       {
94137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94138       };
94139     } catch (std::exception& e) {
94140       {
94141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94142       };
94143     } catch (Dali::DaliException e) {
94144       {
94145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94146       };
94147     } catch (...) {
94148       {
94149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94150       };
94151     }
94152   }
94153
94154   jresult = result;
94155   return jresult;
94156 }
94157
94158
94159 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
94160   unsigned int jresult ;
94161   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94162   float arg2 ;
94163   bool arg3 ;
94164   unsigned int result;
94165
94166   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94167   arg2 = (float)jarg2;
94168   arg3 = jarg3 ? true : false;
94169   {
94170     try {
94171       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
94172     } catch (std::out_of_range& e) {
94173       {
94174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94175       };
94176     } catch (std::exception& e) {
94177       {
94178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94179       };
94180     } catch (Dali::DaliException e) {
94181       {
94182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94183       };
94184     } catch (...) {
94185       {
94186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94187       };
94188     }
94189   }
94190
94191   jresult = result;
94192   return jresult;
94193 }
94194
94195
94196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
94197   unsigned int jresult ;
94198   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94199   unsigned int result;
94200
94201   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94202   {
94203     try {
94204       result = (unsigned int)(*arg1)->GetTotalPages();
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 = result;
94225   return jresult;
94226 }
94227
94228
94229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
94230   int jresult ;
94231   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94232   Dali::Toolkit::Ruler::RulerType result;
94233
94234   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94235   {
94236     try {
94237       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
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 = (int)result;
94258   return jresult;
94259 }
94260
94261
94262 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
94263   unsigned int jresult ;
94264   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94265   bool result;
94266
94267   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94268   {
94269     try {
94270       result = (bool)(*arg1)->IsEnabled();
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 = result;
94291   return jresult;
94292 }
94293
94294
94295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
94296   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94297
94298   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94299   {
94300     try {
94301       (*arg1)->Enable();
94302     } catch (std::out_of_range& e) {
94303       {
94304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94305       };
94306     } catch (std::exception& e) {
94307       {
94308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94309       };
94310     } catch (Dali::DaliException e) {
94311       {
94312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94313       };
94314     } catch (...) {
94315       {
94316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94317       };
94318     }
94319   }
94320
94321 }
94322
94323
94324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
94325   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94326
94327   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94328   {
94329     try {
94330       (*arg1)->Disable();
94331     } catch (std::out_of_range& e) {
94332       {
94333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94334       };
94335     } catch (std::exception& e) {
94336       {
94337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94338       };
94339     } catch (Dali::DaliException e) {
94340       {
94341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94342       };
94343     } catch (...) {
94344       {
94345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94346       };
94347     }
94348   }
94349
94350 }
94351
94352
94353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
94354   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94355   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
94356   Dali::Toolkit::RulerDomain *argp2 ;
94357
94358   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94359   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
94360   if (!argp2) {
94361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
94362     return ;
94363   }
94364   arg2 = *argp2;
94365   {
94366     try {
94367       (*arg1)->SetDomain(arg2);
94368     } catch (std::out_of_range& e) {
94369       {
94370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94371       };
94372     } catch (std::exception& e) {
94373       {
94374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94375       };
94376     } catch (Dali::DaliException e) {
94377       {
94378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94379       };
94380     } catch (...) {
94381       {
94382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94383       };
94384     }
94385   }
94386
94387 }
94388
94389
94390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
94391   void * jresult ;
94392   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94393   Dali::Toolkit::RulerDomain *result = 0 ;
94394
94395   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94396   {
94397     try {
94398       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
94399     } catch (std::out_of_range& e) {
94400       {
94401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94402       };
94403     } catch (std::exception& e) {
94404       {
94405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94406       };
94407     } catch (Dali::DaliException e) {
94408       {
94409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94410       };
94411     } catch (...) {
94412       {
94413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94414       };
94415     }
94416   }
94417
94418   jresult = (void *)result;
94419   return jresult;
94420 }
94421
94422
94423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
94424   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94425
94426   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94427   {
94428     try {
94429       (*arg1)->DisableDomain();
94430     } catch (std::out_of_range& e) {
94431       {
94432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94433       };
94434     } catch (std::exception& e) {
94435       {
94436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94437       };
94438     } catch (Dali::DaliException e) {
94439       {
94440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94441       };
94442     } catch (...) {
94443       {
94444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94445       };
94446     }
94447   }
94448
94449 }
94450
94451
94452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
94453   float jresult ;
94454   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94455   float arg2 ;
94456   float arg3 ;
94457   float arg4 ;
94458   float result;
94459
94460   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94461   arg2 = (float)jarg2;
94462   arg3 = (float)jarg3;
94463   arg4 = (float)jarg4;
94464   {
94465     try {
94466       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
94467     } catch (std::out_of_range& e) {
94468       {
94469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94470       };
94471     } catch (std::exception& e) {
94472       {
94473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94474       };
94475     } catch (Dali::DaliException e) {
94476       {
94477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94478       };
94479     } catch (...) {
94480       {
94481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94482       };
94483     }
94484   }
94485
94486   jresult = result;
94487   return jresult;
94488 }
94489
94490
94491 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
94492   float jresult ;
94493   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94494   float arg2 ;
94495   float arg3 ;
94496   float result;
94497
94498   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94499   arg2 = (float)jarg2;
94500   arg3 = (float)jarg3;
94501   {
94502     try {
94503       result = (float)(*arg1)->Clamp(arg2,arg3);
94504     } catch (std::out_of_range& e) {
94505       {
94506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94507       };
94508     } catch (std::exception& e) {
94509       {
94510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94511       };
94512     } catch (Dali::DaliException e) {
94513       {
94514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94515       };
94516     } catch (...) {
94517       {
94518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94519       };
94520     }
94521   }
94522
94523   jresult = result;
94524   return jresult;
94525 }
94526
94527
94528 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
94529   float jresult ;
94530   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94531   float arg2 ;
94532   float result;
94533
94534   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94535   arg2 = (float)jarg2;
94536   {
94537     try {
94538       result = (float)(*arg1)->Clamp(arg2);
94539     } catch (std::out_of_range& e) {
94540       {
94541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94542       };
94543     } catch (std::exception& e) {
94544       {
94545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94546       };
94547     } catch (Dali::DaliException e) {
94548       {
94549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94550       };
94551     } catch (...) {
94552       {
94553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94554       };
94555     }
94556   }
94557
94558   jresult = result;
94559   return jresult;
94560 }
94561
94562
94563 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
94564   float jresult ;
94565   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94566   float arg2 ;
94567   float arg3 ;
94568   float arg4 ;
94569   Dali::Toolkit::ClampState *arg5 = 0 ;
94570   float result;
94571
94572   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94573   arg2 = (float)jarg2;
94574   arg3 = (float)jarg3;
94575   arg4 = (float)jarg4;
94576   arg5 = (Dali::Toolkit::ClampState *)jarg5;
94577   if (!arg5) {
94578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
94579     return 0;
94580   }
94581   {
94582     try {
94583       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
94584     } catch (std::out_of_range& e) {
94585       {
94586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94587       };
94588     } catch (std::exception& e) {
94589       {
94590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94591       };
94592     } catch (Dali::DaliException e) {
94593       {
94594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94595       };
94596     } catch (...) {
94597       {
94598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94599       };
94600     }
94601   }
94602
94603   jresult = result;
94604   return jresult;
94605 }
94606
94607
94608 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
94609   float jresult ;
94610   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94611   float arg2 ;
94612   float arg3 ;
94613   float arg4 ;
94614   float arg5 ;
94615   float result;
94616
94617   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94618   arg2 = (float)jarg2;
94619   arg3 = (float)jarg3;
94620   arg4 = (float)jarg4;
94621   arg5 = (float)jarg5;
94622   {
94623     try {
94624       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
94625     } catch (std::out_of_range& e) {
94626       {
94627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94628       };
94629     } catch (std::exception& e) {
94630       {
94631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94632       };
94633     } catch (Dali::DaliException e) {
94634       {
94635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94636       };
94637     } catch (...) {
94638       {
94639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94640       };
94641     }
94642   }
94643
94644   jresult = result;
94645   return jresult;
94646 }
94647
94648
94649 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
94650   float jresult ;
94651   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94652   float arg2 ;
94653   float arg3 ;
94654   float arg4 ;
94655   float result;
94656
94657   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94658   arg2 = (float)jarg2;
94659   arg3 = (float)jarg3;
94660   arg4 = (float)jarg4;
94661   {
94662     try {
94663       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
94664     } catch (std::out_of_range& e) {
94665       {
94666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94667       };
94668     } catch (std::exception& e) {
94669       {
94670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94671       };
94672     } catch (Dali::DaliException e) {
94673       {
94674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94675       };
94676     } catch (...) {
94677       {
94678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94679       };
94680     }
94681   }
94682
94683   jresult = result;
94684   return jresult;
94685 }
94686
94687
94688 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
94689   float jresult ;
94690   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94691   float arg2 ;
94692   float arg3 ;
94693   float result;
94694
94695   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94696   arg2 = (float)jarg2;
94697   arg3 = (float)jarg3;
94698   {
94699     try {
94700       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
94701     } catch (std::out_of_range& e) {
94702       {
94703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94704       };
94705     } catch (std::exception& e) {
94706       {
94707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94708       };
94709     } catch (Dali::DaliException e) {
94710       {
94711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94712       };
94713     } catch (...) {
94714       {
94715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94716       };
94717     }
94718   }
94719
94720   jresult = result;
94721   return jresult;
94722 }
94723
94724
94725 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
94726   float jresult ;
94727   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94728   float arg2 ;
94729   float result;
94730
94731   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94732   arg2 = (float)jarg2;
94733   {
94734     try {
94735       result = (float)(*arg1)->SnapAndClamp(arg2);
94736     } catch (std::out_of_range& e) {
94737       {
94738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94739       };
94740     } catch (std::exception& e) {
94741       {
94742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94743       };
94744     } catch (Dali::DaliException e) {
94745       {
94746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94747       };
94748     } catch (...) {
94749       {
94750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94751       };
94752     }
94753   }
94754
94755   jresult = result;
94756   return jresult;
94757 }
94758
94759
94760 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
94761   float jresult ;
94762   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94763   float arg2 ;
94764   float arg3 ;
94765   float arg4 ;
94766   float arg5 ;
94767   Dali::Toolkit::ClampState *arg6 = 0 ;
94768   float result;
94769
94770   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94771   arg2 = (float)jarg2;
94772   arg3 = (float)jarg3;
94773   arg4 = (float)jarg4;
94774   arg5 = (float)jarg5;
94775   arg6 = (Dali::Toolkit::ClampState *)jarg6;
94776   if (!arg6) {
94777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
94778     return 0;
94779   }
94780   {
94781     try {
94782       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
94783     } catch (std::out_of_range& e) {
94784       {
94785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94786       };
94787     } catch (std::exception& e) {
94788       {
94789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94790       };
94791     } catch (Dali::DaliException e) {
94792       {
94793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94794       };
94795     } catch (...) {
94796       {
94797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94798       };
94799     }
94800   }
94801
94802   jresult = result;
94803   return jresult;
94804 }
94805
94806
94807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
94808   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94809
94810   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94811   {
94812     try {
94813       (*arg1)->Reference();
94814     } catch (std::out_of_range& e) {
94815       {
94816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94817       };
94818     } catch (std::exception& e) {
94819       {
94820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94821       };
94822     } catch (Dali::DaliException e) {
94823       {
94824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94825       };
94826     } catch (...) {
94827       {
94828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94829       };
94830     }
94831   }
94832
94833 }
94834
94835
94836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
94837   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94838
94839   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94840   {
94841     try {
94842       (*arg1)->Unreference();
94843     } catch (std::out_of_range& e) {
94844       {
94845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94846       };
94847     } catch (std::exception& e) {
94848       {
94849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94850       };
94851     } catch (Dali::DaliException e) {
94852       {
94853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94854       };
94855     } catch (...) {
94856       {
94857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94858       };
94859     }
94860   }
94861
94862 }
94863
94864
94865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
94866   int jresult ;
94867   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94868   int result;
94869
94870   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94871   {
94872     try {
94873       result = (int)(*arg1)->ReferenceCount();
94874     } catch (std::out_of_range& e) {
94875       {
94876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94877       };
94878     } catch (std::exception& e) {
94879       {
94880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94881       };
94882     } catch (Dali::DaliException e) {
94883       {
94884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94885       };
94886     } catch (...) {
94887       {
94888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94889       };
94890     }
94891   }
94892
94893   jresult = result;
94894   return jresult;
94895 }
94896
94897
94898 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
94899   unsigned int jresult ;
94900   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94901   bool result;
94902
94903   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94904   {
94905     try {
94906       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
94907     } catch (std::out_of_range& e) {
94908       {
94909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94910       };
94911     } catch (std::exception& e) {
94912       {
94913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94914       };
94915     } catch (Dali::DaliException e) {
94916       {
94917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94918       };
94919     } catch (...) {
94920       {
94921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94922       };
94923     }
94924   }
94925
94926   jresult = result;
94927   return jresult;
94928 }
94929
94930
94931 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
94932   unsigned long jresult ;
94933   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94934   std::size_t result;
94935
94936   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94937   {
94938     try {
94939       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
94940     } catch (std::out_of_range& e) {
94941       {
94942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94943       };
94944     } catch (std::exception& e) {
94945       {
94946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94947       };
94948     } catch (Dali::DaliException e) {
94949       {
94950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94951       };
94952     } catch (...) {
94953       {
94954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94955       };
94956     }
94957   }
94958
94959   jresult = (unsigned long)result;
94960   return jresult;
94961 }
94962
94963
94964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
94965   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94966   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
94967
94968   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94969   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
94970   {
94971     try {
94972       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
94973     } catch (std::out_of_range& e) {
94974       {
94975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94976       };
94977     } catch (std::exception& e) {
94978       {
94979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94980       };
94981     } catch (Dali::DaliException e) {
94982       {
94983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94984       };
94985     } catch (...) {
94986       {
94987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94988       };
94989     }
94990   }
94991
94992 }
94993
94994
94995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
94996   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94997   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
94998
94999   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95000   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95001   {
95002     try {
95003       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
95004     } catch (std::out_of_range& e) {
95005       {
95006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95007       };
95008     } catch (std::exception& e) {
95009       {
95010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95011       };
95012     } catch (Dali::DaliException e) {
95013       {
95014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95015       };
95016     } catch (...) {
95017       {
95018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95019       };
95020     }
95021   }
95022
95023 }
95024
95025
95026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
95027   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95028   Dali::Toolkit::Control arg2 ;
95029   Dali::Toolkit::Control *argp2 ;
95030
95031   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95032   argp2 = (Dali::Toolkit::Control *)jarg2;
95033   if (!argp2) {
95034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
95035     return ;
95036   }
95037   arg2 = *argp2;
95038   {
95039     try {
95040       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
95041     } catch (std::out_of_range& e) {
95042       {
95043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95044       };
95045     } catch (std::exception& e) {
95046       {
95047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95048       };
95049     } catch (Dali::DaliException e) {
95050       {
95051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95052       };
95053     } catch (...) {
95054       {
95055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95056       };
95057     }
95058   }
95059
95060 }
95061
95062
95063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
95064   void * jresult ;
95065   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
95066
95067   {
95068     try {
95069       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
95070     } catch (std::out_of_range& e) {
95071       {
95072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95073       };
95074     } catch (std::exception& e) {
95075       {
95076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95077       };
95078     } catch (Dali::DaliException e) {
95079       {
95080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95081       };
95082     } catch (...) {
95083       {
95084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95085       };
95086     }
95087   }
95088
95089   jresult = (void *)result;
95090   return jresult;
95091 }
95092
95093
95094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
95095   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95096
95097   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95098   {
95099     try {
95100       delete arg1;
95101     } catch (std::out_of_range& e) {
95102       {
95103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95104       };
95105     } catch (std::exception& e) {
95106       {
95107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95108       };
95109     } catch (Dali::DaliException e) {
95110       {
95111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95112       };
95113     } catch (...) {
95114       {
95115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95116       };
95117     }
95118   }
95119
95120 }
95121
95122 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
95123   Dali::RefObject *result = NULL;
95124
95125   if (arg1)
95126   {
95127     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
95128   }
95129   return result;
95130 }
95131
95132 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
95133     return (Dali::RefObject *)jarg1;
95134 }
95135
95136 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
95137     return (Dali::SignalObserver *)jarg1;
95138 }
95139
95140 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
95141     return (Dali::ConnectionTrackerInterface *)jarg1;
95142 }
95143
95144 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
95145     return (Dali::BaseHandle *)jarg1;
95146 }
95147
95148 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
95149     return (Dali::BaseHandle *)jarg1;
95150 }
95151
95152 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
95153     return (Dali::BaseHandle *)jarg1;
95154 }
95155
95156 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
95157     return (Dali::BaseHandle *)jarg1;
95158 }
95159
95160 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
95161     return (Dali::BaseHandle *)jarg1;
95162 }
95163
95164 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
95165     return (Dali::BaseHandle *)jarg1;
95166 }
95167
95168 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
95169     return (Dali::BaseHandle *)jarg1;
95170 }
95171
95172 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
95173     return (Dali::BaseHandle *)jarg1;
95174 }
95175
95176 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
95177     return (Dali::BaseHandle *)jarg1;
95178 }
95179
95180 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
95181     return (Dali::BaseHandle *)jarg1;
95182 }
95183
95184 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
95185     return (Dali::BaseHandle *)jarg1;
95186 }
95187
95188 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
95189     return (Dali::BaseHandle *)jarg1;
95190 }
95191
95192 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
95193     return (Dali::Handle *)jarg1;
95194 }
95195
95196 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
95197     return (Dali::Handle *)jarg1;
95198 }
95199
95200 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
95201     return (Dali::BaseHandle *)jarg1;
95202 }
95203
95204 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
95205     return (Dali::BaseHandle *)jarg1;
95206 }
95207
95208 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
95209     return (Dali::Handle *)jarg1;
95210 }
95211
95212 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
95213     return (Dali::BaseHandle *)jarg1;
95214 }
95215
95216 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
95217     return (Dali::Handle *)jarg1;
95218 }
95219
95220 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
95221     return (Dali::GestureDetector *)jarg1;
95222 }
95223
95224 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
95225     return (Dali::Gesture *)jarg1;
95226 }
95227
95228 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
95229     return (Dali::Handle *)jarg1;
95230 }
95231
95232 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
95233     return (Dali::Actor *)jarg1;
95234 }
95235
95236 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
95237     return (Dali::RefObject *)jarg1;
95238 }
95239
95240 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
95241     return (Dali::Actor *)jarg1;
95242 }
95243
95244 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
95245     return (Dali::GestureDetector *)jarg1;
95246 }
95247
95248 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
95249     return (Dali::Gesture *)jarg1;
95250 }
95251
95252 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
95253     return (Dali::GestureDetector *)jarg1;
95254 }
95255
95256 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
95257     return (Dali::Gesture *)jarg1;
95258 }
95259
95260 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
95261     return (Dali::GestureDetector *)jarg1;
95262 }
95263
95264 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
95265     return (Dali::Gesture *)jarg1;
95266 }
95267
95268 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
95269     return (Dali::BaseHandle *)jarg1;
95270 }
95271
95272 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
95273     return (Dali::Handle *)jarg1;
95274 }
95275
95276 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
95277     return (Dali::Handle *)jarg1;
95278 }
95279
95280 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
95281     return (Dali::Handle *)jarg1;
95282 }
95283
95284 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
95285     return (Dali::RefObject *)jarg1;
95286 }
95287
95288 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
95289     return (Dali::Actor *)jarg1;
95290 }
95291
95292 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
95293     return (Dali::BaseHandle *)jarg1;
95294 }
95295
95296 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
95297     return (Dali::BaseHandle *)jarg1;
95298 }
95299
95300 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
95301     return (Dali::BaseHandle *)jarg1;
95302 }
95303
95304 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
95305     return (Dali::CustomActorImpl *)jarg1;
95306 }
95307
95308 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
95309     return (Dali::CustomActor *)jarg1;
95310 }
95311
95312 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
95313     return (Dali::BaseHandle *)jarg1;
95314 }
95315
95316 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
95317     return (Dali::Toolkit::Control *)jarg1;
95318 }
95319
95320 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
95321     return (Dali::Toolkit::Control *)jarg1;
95322 }
95323
95324 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
95325     return (Dali::Toolkit::Button *)jarg1;
95326 }
95327
95328 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
95329     return (Dali::Toolkit::Button *)jarg1;
95330 }
95331
95332 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
95333     return (Dali::Toolkit::Button *)jarg1;
95334 }
95335
95336 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
95337     return (Dali::Toolkit::Control *)jarg1;
95338 }
95339
95340 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
95341     return (Dali::Toolkit::Control *)jarg1;
95342 }
95343
95344 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
95345     return (Dali::Toolkit::Control *)jarg1;
95346 }
95347
95348 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
95349     return (Dali::Toolkit::Control *)jarg1;
95350 }
95351
95352 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
95353     return (Dali::Toolkit::Control *)jarg1;
95354 }
95355
95356 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
95357     return (Dali::RefObject *)jarg1;
95358 }
95359
95360 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
95361     return (Dali::Toolkit::Scrollable *)jarg1;
95362 }
95363
95364 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
95365     return (Dali::BaseHandle *)jarg1;
95366 }
95367
95368 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
95369     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
95370 }
95371
95372 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
95373     return (Dali::RefObject *)jarg1;
95374 }
95375
95376 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
95377     return (Dali::Toolkit::Ruler *)jarg1;
95378 }
95379
95380 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
95381     return (Dali::Toolkit::Ruler *)jarg1;
95382 }
95383
95384 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
95385     return (Dali::Toolkit::Scrollable *)jarg1;
95386 }
95387
95388 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
95389     return (Dali::Toolkit::Control *)jarg1;
95390 }
95391
95392
95393 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
95394     return (Dali::Toolkit::Control *)jarg1;
95395 }
95396
95397 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
95398     return (Dali::BaseHandle *)jarg1;
95399 }
95400
95401 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
95402     return (Dali::BaseHandle *)jarg1;
95403 }
95404
95405 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
95406     return (Dali::Toolkit::Control *)jarg1;
95407 }
95408
95409 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
95410     return (Dali::Toolkit::Control *)jarg1;
95411 }
95412
95413 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
95414     return (Dali::Toolkit::Control *)jarg1;
95415 }
95416
95417 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
95418     return (Dali::Toolkit::Control *)jarg1;
95419 }
95420
95421 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
95422     return (Dali::Toolkit::Control *)jarg1;
95423 }
95424
95425 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
95426     return (Dali::Toolkit::Control *)jarg1;
95427 }
95428
95429 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
95430     return (Dali::Toolkit::PageTurnView *)jarg1;
95431 }
95432
95433 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
95434     return (Dali::Toolkit::PageTurnView *)jarg1;
95435 }
95436
95437 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
95438     return (Dali::Toolkit::Button *)jarg1;
95439 }
95440
95441 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
95442     return (Dali::BaseHandle *)jarg1;
95443 }
95444
95445 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
95446     return (Dali::BaseHandle *)jarg1;
95447 }
95448
95449 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
95450     return (Dali::BaseHandle *)jarg1;
95451 }
95452
95453 /*
95454  * Widget binding
95455  */
95456 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
95457     return (Dali::BaseHandle *)jarg1;
95458 }
95459
95460 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
95461     return (Dali::BaseObject *)jarg1;
95462 }
95463
95464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
95465   void * jresult ;
95466   Dali::Widget result;
95467
95468   {
95469     try {
95470       result = Dali::Widget::New();
95471     } catch (std::out_of_range& e) {
95472       {
95473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95474       };
95475     } catch (std::exception& e) {
95476       {
95477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95478       };
95479     } catch (...) {
95480       {
95481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95482       };
95483     }
95484   }
95485   jresult = new Dali::Widget((const Dali::Widget &)result);
95486   return jresult;
95487 }
95488
95489
95490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
95491   void * jresult ;
95492   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
95493   Dali::Widget result;
95494
95495   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95496
95497   if (!arg1) {
95498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
95499     return 0;
95500   }
95501   {
95502     try {
95503       jresult = new Dali::Widget(arg1);
95504     } catch (std::out_of_range& e) {
95505       {
95506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95507       };
95508     } catch (std::exception& e) {
95509       {
95510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95511       };
95512     } catch (...) {
95513       {
95514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95515       };
95516     }
95517   }
95518   return jresult;
95519 }
95520
95521
95522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
95523   void * jresult ;
95524   Dali::Widget *result = 0 ;
95525
95526   {
95527     try {
95528       result = (Dali::Widget *)new Dali::Widget();
95529     } catch (std::out_of_range& e) {
95530       {
95531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95532       };
95533     } catch (std::exception& e) {
95534       {
95535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95536       };
95537     } catch (...) {
95538       {
95539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95540       };
95541     }
95542   }
95543   jresult = (void *)result;
95544   return jresult;
95545 }
95546
95547
95548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
95549   void * jresult ;
95550   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
95551   Dali::Widget *arg2 = 0 ;
95552   Dali::Widget *result = 0 ;
95553
95554   arg1 = (Dali::Widget *)jarg1;
95555   arg2 = (Dali::Widget *)jarg2;
95556   if (!arg2) {
95557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
95558     return 0;
95559   }
95560   {
95561     try {
95562       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
95563     } catch (std::out_of_range& e) {
95564       {
95565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95566       };
95567     } catch (std::exception& e) {
95568       {
95569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95570       };
95571     } catch (...) {
95572       {
95573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95574       };
95575     }
95576   }
95577   jresult = (void *)result;
95578   return jresult;
95579 }
95580
95581
95582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
95583   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
95584
95585   arg1 = (Dali::Widget *)jarg1;
95586   {
95587     try {
95588       delete arg1;
95589     } catch (std::out_of_range& e) {
95590       {
95591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95592       };
95593     } catch (std::exception& e) {
95594       {
95595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95596       };
95597     } catch (...) {
95598       {
95599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95600       };
95601     }
95602   }
95603 }
95604
95605
95606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
95607   void * jresult ;
95608   SwigDirector_WidgetImpl* result;
95609   {
95610     try {
95611       result = new SwigDirector_WidgetImpl();
95612     } catch (std::out_of_range& e) {
95613       {
95614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95615       };
95616     } catch (std::exception& e) {
95617       {
95618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95619       };
95620     } catch (...) {
95621       {
95622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95623       };
95624     }
95625   }
95626   jresult = result;
95627   return jresult;
95628 }
95629
95630
95631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
95632   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95633   std::string *arg2 = 0 ;
95634   Dali::Window arg3 ;
95635   Dali::Window *argp3 ;
95636
95637   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95638   if (!jarg2) {
95639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95640     return ;
95641   }
95642   std::string arg2_str(jarg2);
95643   arg2 = &arg2_str;
95644   argp3 = (Dali::Window *)jarg3;
95645   if (!argp3) {
95646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95647     return ;
95648   }
95649   arg3 = *argp3;
95650   {
95651     try {
95652       (arg1)->OnCreate((std::string const &)*arg2,arg3);
95653     } catch (std::out_of_range& e) {
95654       {
95655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95656       };
95657     } catch (std::exception& e) {
95658       {
95659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95660       };
95661     } catch (...) {
95662       {
95663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95664       };
95665     }
95666   }
95667 }
95668
95669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
95670   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95671   std::string *arg2 = 0 ;
95672   Dali::Window arg3 ;
95673   Dali::Window *argp3 ;
95674
95675   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95676   if (!jarg2) {
95677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95678     return ;
95679   }
95680   std::string arg2_str(jarg2);
95681   arg2 = &arg2_str;
95682   argp3 = (Dali::Window *)jarg3;
95683   if (!argp3) {
95684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95685     return ;
95686   }
95687   arg3 = *argp3;
95688   {
95689     try {
95690       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
95691     } catch (std::out_of_range& e) {
95692       {
95693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95694       };
95695     } catch (std::exception& e) {
95696       {
95697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95698       };
95699     } catch (...) {
95700       {
95701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95702       };
95703     }
95704   }
95705 }
95706
95707
95708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
95709   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95710   std::string *arg2 = 0 ;
95711   Dali::Widget::Termination arg3 ;
95712
95713   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95714   if (!jarg2) {
95715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95716     return ;
95717   }
95718   std::string arg2_str(jarg2);
95719   arg2 = &arg2_str;
95720   arg3 = (Dali::Widget::Termination)jarg3;
95721   {
95722     try {
95723       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
95724     } catch (std::out_of_range& e) {
95725       {
95726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95727       };
95728     } catch (std::exception& e) {
95729       {
95730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95731       };
95732     } catch (...) {
95733       {
95734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95735       };
95736     }
95737   }
95738 }
95739
95740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
95741   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95742   std::string *arg2 = 0 ;
95743   Dali::Widget::Termination arg3 ;
95744
95745   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95746   if (!jarg2) {
95747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95748     return ;
95749   }
95750   std::string arg2_str(jarg2);
95751   arg2 = &arg2_str;
95752   arg3 = (Dali::Widget::Termination)jarg3;
95753   {
95754     try {
95755       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
95756     } catch (std::out_of_range& e) {
95757       {
95758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95759       };
95760     } catch (std::exception& e) {
95761       {
95762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95763       };
95764     } catch (...) {
95765       {
95766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95767       };
95768     }
95769   }
95770 }
95771
95772
95773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
95774   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95775
95776   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95777   {
95778     try {
95779       (arg1)->OnPause();
95780     } catch (std::out_of_range& e) {
95781       {
95782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95783       };
95784     } catch (std::exception& e) {
95785       {
95786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95787       };
95788     } catch (...) {
95789       {
95790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95791       };
95792     }
95793   }
95794 }
95795
95796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
95797   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95798
95799   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95800   {
95801     try {
95802       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
95803     } catch (std::out_of_range& e) {
95804       {
95805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95806       };
95807     } catch (std::exception& e) {
95808       {
95809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95810       };
95811     } catch (...) {
95812       {
95813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95814       };
95815     }
95816   }
95817 }
95818
95819
95820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
95821   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95822
95823   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95824   {
95825     try {
95826       (arg1)->OnResume();
95827     } catch (std::out_of_range& e) {
95828       {
95829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95830       };
95831     } catch (std::exception& e) {
95832       {
95833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95834       };
95835     } catch (...) {
95836       {
95837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95838       };
95839     }
95840   }
95841 }
95842
95843
95844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
95845   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95846
95847   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95848   {
95849     try {
95850       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
95851     } catch (std::out_of_range& e) {
95852       {
95853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95854       };
95855     } catch (std::exception& e) {
95856       {
95857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95858       };
95859     } catch (...) {
95860       {
95861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95862       };
95863     }
95864   }
95865 }
95866
95867
95868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
95869   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95870   Dali::Window arg2 ;
95871   Dali::Window *argp2 ;
95872
95873   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95874   argp2 = (Dali::Window *)jarg2;
95875   if (!argp2) {
95876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95877     return ;
95878   }
95879   arg2 = *argp2;
95880   {
95881     try {
95882       (arg1)->OnResize(arg2);
95883     } catch (std::out_of_range& e) {
95884       {
95885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95886       };
95887     } catch (std::exception& e) {
95888       {
95889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95890       };
95891     } catch (...) {
95892       {
95893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95894       };
95895     }
95896   }
95897 }
95898
95899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
95900   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95901   Dali::Window arg2 ;
95902   Dali::Window *argp2 ;
95903
95904   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95905   argp2 = (Dali::Window *)jarg2;
95906   if (!argp2) {
95907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95908     return ;
95909   }
95910   arg2 = *argp2;
95911   {
95912     try {
95913       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
95914     } catch (std::out_of_range& e) {
95915       {
95916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95917       };
95918     } catch (std::exception& e) {
95919       {
95920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95921       };
95922     } catch (...) {
95923       {
95924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95925       };
95926     }
95927   }
95928 }
95929
95930
95931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
95932   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95933   std::string *arg2 = 0 ;
95934   int arg3 ;
95935
95936   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95937   if (!jarg2) {
95938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95939     return ;
95940   }
95941   std::string arg2_str(jarg2);
95942   arg2 = &arg2_str;
95943   arg3 = (int)jarg3;
95944   {
95945     try {
95946       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
95947     } catch (std::out_of_range& e) {
95948       {
95949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95950       };
95951     } catch (std::exception& e) {
95952       {
95953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95954       };
95955     } catch (...) {
95956       {
95957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95958       };
95959     }
95960   }
95961 }
95962
95963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
95964   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95965   std::string *arg2 = 0 ;
95966   int arg3 ;
95967
95968   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95969   if (!jarg2) {
95970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95971     return ;
95972   }
95973   std::string arg2_str(jarg2);
95974   arg2 = &arg2_str;
95975   arg3 = (int)jarg3;
95976   {
95977     try {
95978       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
95979     } catch (std::out_of_range& e) {
95980       {
95981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95982       };
95983     } catch (std::exception& e) {
95984       {
95985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95986       };
95987     } catch (...) {
95988       {
95989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95990       };
95991     }
95992   }
95993 }
95994
95995
95996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
95997   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95998   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
95999   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96000
96001   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96002   arg2 = (Dali::SlotObserver *)jarg2;
96003   arg3 = (Dali::CallbackBase *)jarg3;
96004   {
96005     try {
96006       (arg1)->SignalConnected(arg2,arg3);
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 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96024   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96025   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96026   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96027
96028   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96029   arg2 = (Dali::SlotObserver *)jarg2;
96030   arg3 = (Dali::CallbackBase *)jarg3;
96031   {
96032     try {
96033       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
96034     } catch (std::out_of_range& e) {
96035       {
96036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96037       };
96038     } catch (std::exception& e) {
96039       {
96040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96041       };
96042     } catch (...) {
96043       {
96044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96045       };
96046     }
96047   }
96048 }
96049
96050
96051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
96052   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96053   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96054   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96055
96056   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96057   arg2 = (Dali::SlotObserver *)jarg2;
96058   arg3 = (Dali::CallbackBase *)jarg3;
96059   {
96060     try {
96061       (arg1)->SignalDisconnected(arg2,arg3);
96062     } catch (std::out_of_range& e) {
96063       {
96064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96065       };
96066     } catch (std::exception& e) {
96067       {
96068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96069       };
96070     } catch (...) {
96071       {
96072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96073       };
96074     }
96075   }
96076 }
96077
96078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96079   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96080   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96081   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96082
96083   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96084   arg2 = (Dali::SlotObserver *)jarg2;
96085   arg3 = (Dali::CallbackBase *)jarg3;
96086   {
96087     try {
96088       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
96089     } catch (std::out_of_range& e) {
96090       {
96091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96092       };
96093     } catch (std::exception& e) {
96094       {
96095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96096       };
96097     } catch (...) {
96098       {
96099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96100       };
96101     }
96102   }
96103 }
96104
96105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
96106   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96107   std::string *arg2 = 0 ;
96108
96109   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96110   if (!jarg2) {
96111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96112     return ;
96113   }
96114   std::string arg2_str(jarg2);
96115   arg2 = &arg2_str;
96116   {
96117     try {
96118       (arg1)->SetContentInfo((std::string const &)*arg2);
96119     } catch (std::out_of_range& e) {
96120       {
96121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96122       };
96123     } catch (std::exception& e) {
96124       {
96125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96126       };
96127     } catch (...) {
96128       {
96129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96130       };
96131     }
96132   }
96133 }
96134
96135
96136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
96137   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96138   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
96139
96140   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96141   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
96142   {
96143     try {
96144       (arg1)->SetImpl(arg2);
96145     } catch (std::out_of_range& e) {
96146       {
96147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96148       };
96149     } catch (std::exception& e) {
96150       {
96151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96152       };
96153     } catch (...) {
96154       {
96155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96156       };
96157     }
96158   }
96159 }
96160
96161 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) {
96162
96163   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
96164   if (director) {
96165     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
96166   }
96167 }
96168
96169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
96170   void * jresult ;
96171   Dali::Widget *arg1 = 0 ;
96172   SwigDirector_WidgetImpl *result = 0 ;
96173
96174   arg1 = (Dali::Widget *)jarg1;
96175   if (!arg1) {
96176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
96177     return 0;
96178   }
96179   {
96180     try {
96181       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
96182     } catch (std::out_of_range& e) {
96183       {
96184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96185       };
96186     } catch (std::exception& e) {
96187       {
96188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96189       };
96190     } catch (...) {
96191       {
96192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96193       };
96194     }
96195   }
96196
96197   jresult = (void *)result;
96198   return jresult;
96199 }
96200
96201
96202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
96203   void * jresult ;
96204   int *arg1 = (int *) 0 ;
96205   char ***arg2 ;
96206   std::string *arg3 = 0 ;
96207   Dali::WidgetApplication result;
96208   {
96209     int index = 0;
96210     int length = 0;
96211     char *retPtr;
96212     char *nextPtr;
96213     argWidgetC = jarg1;
96214     argWidgetV = new char*[jarg1 + 1];
96215
96216     retPtr = strtok_r( jarg2, " ", &nextPtr);
96217     if( retPtr )
96218     {
96219       length = strlen(retPtr);
96220     }
96221     argWidgetV[index] = new char[length + 1];
96222     if( retPtr )
96223     {
96224       strncpy(argWidgetV[index], retPtr, length);
96225     }
96226     argWidgetV[index][length] = '\0';
96227     index++;
96228
96229     while (index < jarg1)
96230     {
96231       length = 0;
96232       retPtr = strtok_r(NULL, " ", &nextPtr);
96233       if( retPtr )
96234       {
96235         length = strlen(retPtr);
96236       }
96237       argWidgetV[index] = new char[length + 1];
96238       if( retPtr )
96239       {
96240         strncpy(argWidgetV[index], retPtr, length);
96241       }
96242       argWidgetV[index][length] = '\0';
96243       index++;
96244     }
96245
96246     argWidgetV[jarg1] = NULL;
96247     argWidgetC = jarg1;
96248
96249     arg1 = &argWidgetC;
96250     arg2 = &argWidgetV;
96251   }
96252
96253   if (!jarg3) {
96254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96255     return 0;
96256   }
96257   std::string arg3_str(jarg3);
96258   arg3 = &arg3_str;
96259   {
96260     try {
96261       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
96262     } catch (std::out_of_range& e) {
96263       {
96264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96265       };
96266     } catch (std::exception& e) {
96267       {
96268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96269       };
96270     } catch (...) {
96271       {
96272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96273       };
96274     }
96275   }
96276   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
96277
96278   return jresult;
96279 }
96280
96281
96282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
96283   void * jresult ;
96284   Dali::WidgetApplication *result = 0 ;
96285
96286   {
96287     try {
96288       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
96289     } catch (std::out_of_range& e) {
96290       {
96291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96292       };
96293     } catch (std::exception& e) {
96294       {
96295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96296       };
96297     } catch (...) {
96298       {
96299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96300       };
96301     }
96302   }
96303   jresult = (void *)result;
96304   return jresult;
96305 }
96306
96307
96308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
96309   void * jresult ;
96310   Dali::WidgetApplication *arg1 = 0 ;
96311   Dali::WidgetApplication *result = 0 ;
96312
96313   arg1 = (Dali::WidgetApplication *)jarg1;
96314   if (!arg1) {
96315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96316     return 0;
96317   }
96318   {
96319     try {
96320       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
96321     } catch (std::out_of_range& e) {
96322       {
96323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96324       };
96325     } catch (std::exception& e) {
96326       {
96327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96328       };
96329     } catch (...) {
96330       {
96331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96332       };
96333     }
96334   }
96335   jresult = (void *)result;
96336   return jresult;
96337 }
96338
96339
96340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
96341   void * jresult ;
96342   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96343   Dali::WidgetApplication *arg2 = 0 ;
96344   Dali::WidgetApplication *result = 0 ;
96345
96346   arg1 = (Dali::WidgetApplication *)jarg1;
96347   arg2 = (Dali::WidgetApplication *)jarg2;
96348   if (!arg2) {
96349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96350     return 0;
96351   }
96352   {
96353     try {
96354       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
96355     } catch (std::out_of_range& e) {
96356       {
96357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96358       };
96359     } catch (std::exception& e) {
96360       {
96361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96362       };
96363     } catch (...) {
96364       {
96365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96366       };
96367     }
96368   }
96369   jresult = (void *)result;
96370   return jresult;
96371 }
96372
96373
96374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
96375   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96376
96377   arg1 = (Dali::WidgetApplication *)jarg1;
96378   {
96379     try {
96380       delete arg1;
96381       if( argWidgetV )
96382       {
96383         // free string data
96384         for( int i=0; i < argWidgetC+1; i++)
96385         {
96386           delete [] argWidgetV[i];
96387         }
96388         delete [] argWidgetV;
96389       }
96390     } catch (std::out_of_range& e) {
96391       {
96392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96393       };
96394     } catch (std::exception& e) {
96395       {
96396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96397       };
96398     } catch (...) {
96399       {
96400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96401       };
96402     }
96403   }
96404 }
96405
96406
96407 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
96408 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
96409
96410 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
96411 {
96412   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
96413   return *widget;
96414 }
96415
96416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
96417   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96418   std::string *arg2 = 0 ;
96419
96420   arg1 = (Dali::WidgetApplication *)jarg1;
96421   if (!jarg2) {
96422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96423     return ;
96424   }
96425   std::string arg2_str(*jarg2);
96426   arg2 = &arg2_str;
96427
96428   if(!_CSharpCreateWidgetFunction)
96429   {
96430     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
96431   }
96432
96433   {
96434     try {
96435       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
96436     } catch (std::out_of_range& e) {
96437       {
96438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96439       };
96440     } catch (std::exception& e) {
96441       {
96442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96443       };
96444     } catch (...) {
96445       {
96446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96447       };
96448     }
96449   }
96450
96451   //Typemap argout in c++ file.
96452   //This will convert c++ string to c# string
96453   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
96454 }
96455
96456
96457 //for PixelBuffer and ImageLoading
96458
96459 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
96460     return (Dali::BaseHandle *)jarg1;
96461 }
96462
96463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
96464   void * jresult ;
96465   unsigned int arg1 ;
96466   unsigned int arg2 ;
96467   Dali::Pixel::Format arg3 ;
96468   Dali::Devel::PixelBuffer result;
96469
96470   arg1 = (unsigned int)jarg1;
96471   arg2 = (unsigned int)jarg2;
96472   arg3 = (Dali::Pixel::Format)jarg3;
96473   {
96474     try {
96475       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
96476     } catch (std::out_of_range& e) {
96477       {
96478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96479       };
96480     } catch (std::exception& e) {
96481       {
96482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96483       };
96484     } catch (...) {
96485       {
96486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96487       };
96488     }
96489   }
96490   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
96491   return jresult;
96492 }
96493
96494
96495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
96496   void * jresult ;
96497   Dali::Devel::PixelBuffer *result = 0 ;
96498
96499   {
96500     try {
96501       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
96502     } catch (std::out_of_range& e) {
96503       {
96504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96505       };
96506     } catch (std::exception& e) {
96507       {
96508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96509       };
96510     } catch (...) {
96511       {
96512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96513       };
96514     }
96515   }
96516   jresult = (void *)result;
96517   return jresult;
96518 }
96519
96520
96521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
96522   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96523
96524   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96525   {
96526     try {
96527       delete arg1;
96528     } catch (std::out_of_range& e) {
96529       {
96530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96531       };
96532     } catch (std::exception& e) {
96533       {
96534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96535       };
96536     } catch (...) {
96537       {
96538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96539       };
96540     }
96541   }
96542 }
96543
96544
96545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
96546   void * jresult ;
96547   Dali::Devel::PixelBuffer *arg1 = 0 ;
96548   Dali::Devel::PixelBuffer *result = 0 ;
96549
96550   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96551   if (!arg1) {
96552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
96553     return 0;
96554   }
96555   {
96556     try {
96557       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
96558     } catch (std::out_of_range& e) {
96559       {
96560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96561       };
96562     } catch (std::exception& e) {
96563       {
96564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96565       };
96566     } catch (...) {
96567       {
96568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96569       };
96570     }
96571   }
96572   jresult = (void *)result;
96573   return jresult;
96574 }
96575
96576
96577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
96578   void * jresult ;
96579   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96580   Dali::Devel::PixelBuffer *arg2 = 0 ;
96581   Dali::Devel::PixelBuffer *result = 0 ;
96582
96583   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96584   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
96585   if (!arg2) {
96586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
96587     return 0;
96588   }
96589   {
96590     try {
96591       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
96592     } catch (std::out_of_range& e) {
96593       {
96594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96595       };
96596     } catch (std::exception& e) {
96597       {
96598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96599       };
96600     } catch (...) {
96601       {
96602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96603       };
96604     }
96605   }
96606   jresult = (void *)result;
96607   return jresult;
96608 }
96609
96610
96611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
96612   void * jresult ;
96613   Dali::Devel::PixelBuffer *arg1 = 0 ;
96614   Dali::PixelData result;
96615
96616   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96617   if (!arg1) {
96618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
96619     return 0;
96620   }
96621   {
96622     try {
96623       result = Dali::Devel::PixelBuffer::Convert(*arg1);
96624     } catch (std::out_of_range& e) {
96625       {
96626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96627       };
96628     } catch (std::exception& e) {
96629       {
96630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96631       };
96632     } catch (...) {
96633       {
96634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96635       };
96636     }
96637   }
96638   jresult = new Dali::PixelData((const Dali::PixelData &)result);
96639   return jresult;
96640 }
96641
96642
96643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
96644   void * jresult ;
96645   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96646   Dali::PixelData result;
96647
96648   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96649   {
96650     try {
96651       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
96652     } catch (std::out_of_range& e) {
96653       {
96654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96655       };
96656     } catch (std::exception& e) {
96657       {
96658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96659       };
96660     } catch (...) {
96661       {
96662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96663       };
96664     }
96665   }
96666   jresult = new Dali::PixelData((const Dali::PixelData &)result);
96667   return jresult;
96668 }
96669
96670
96671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
96672   void * jresult ;
96673   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96674   unsigned char *result = 0 ;
96675
96676   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96677   {
96678     try {
96679       result = (unsigned char *)(arg1)->GetBuffer();
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 = (void *)result;
96695   return jresult;
96696 }
96697
96698
96699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
96700   unsigned int jresult ;
96701   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96702   unsigned int result;
96703
96704   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96705   {
96706     try {
96707       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
96708     } catch (std::out_of_range& e) {
96709       {
96710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96711       };
96712     } catch (std::exception& e) {
96713       {
96714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96715       };
96716     } catch (...) {
96717       {
96718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96719       };
96720     }
96721   }
96722   jresult = result;
96723   return jresult;
96724 }
96725
96726
96727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
96728   unsigned int jresult ;
96729   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96730   unsigned int result;
96731
96732   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96733   {
96734     try {
96735       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
96736     } catch (std::out_of_range& e) {
96737       {
96738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96739       };
96740     } catch (std::exception& e) {
96741       {
96742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96743       };
96744     } catch (...) {
96745       {
96746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96747       };
96748     }
96749   }
96750   jresult = result;
96751   return jresult;
96752 }
96753
96754
96755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
96756   int jresult ;
96757   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96758   Dali::Pixel::Format result;
96759
96760   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96761   {
96762     try {
96763       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
96764     } catch (std::out_of_range& e) {
96765       {
96766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96767       };
96768     } catch (std::exception& e) {
96769       {
96770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96771       };
96772     } catch (...) {
96773       {
96774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96775       };
96776     }
96777   }
96778   jresult = (int)result;
96779   return jresult;
96780 }
96781
96782
96783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
96784   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96785   Dali::Devel::PixelBuffer arg2 ;
96786   float arg3 ;
96787   bool arg4 ;
96788   Dali::Devel::PixelBuffer *argp2 ;
96789
96790   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96791   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
96792   if (!argp2) {
96793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
96794     return ;
96795   }
96796   arg2 = *argp2;
96797   arg3 = (float)jarg3;
96798   arg4 = jarg4 ? true : false;
96799   {
96800     try {
96801       (arg1)->ApplyMask(arg2,arg3,arg4);
96802     } catch (std::out_of_range& e) {
96803       {
96804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96805       };
96806     } catch (std::exception& e) {
96807       {
96808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96809       };
96810     } catch (...) {
96811       {
96812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96813       };
96814     }
96815   }
96816 }
96817
96818
96819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
96820   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96821   Dali::Devel::PixelBuffer arg2 ;
96822   float arg3 ;
96823   Dali::Devel::PixelBuffer *argp2 ;
96824
96825   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96826   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
96827   if (!argp2) {
96828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
96829     return ;
96830   }
96831   arg2 = *argp2;
96832   arg3 = (float)jarg3;
96833   {
96834     try {
96835       (arg1)->ApplyMask(arg2,arg3);
96836     } catch (std::out_of_range& e) {
96837       {
96838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96839       };
96840     } catch (std::exception& e) {
96841       {
96842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96843       };
96844     } catch (...) {
96845       {
96846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96847       };
96848     }
96849   }
96850 }
96851
96852
96853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
96854   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96855   Dali::Devel::PixelBuffer arg2 ;
96856   Dali::Devel::PixelBuffer *argp2 ;
96857
96858   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96859   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
96860   if (!argp2) {
96861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
96862     return ;
96863   }
96864   arg2 = *argp2;
96865   {
96866     try {
96867       (arg1)->ApplyMask(arg2);
96868     } catch (std::out_of_range& e) {
96869       {
96870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96871       };
96872     } catch (std::exception& e) {
96873       {
96874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96875       };
96876     } catch (...) {
96877       {
96878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96879       };
96880     }
96881   }
96882 }
96883
96884
96885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
96886   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96887   float arg2 ;
96888
96889   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96890   arg2 = (float)jarg2;
96891   {
96892     try {
96893       (arg1)->ApplyGaussianBlur(arg2);
96894     } catch (std::out_of_range& e) {
96895       {
96896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96897       };
96898     } catch (std::exception& e) {
96899       {
96900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96901       };
96902     } catch (...) {
96903       {
96904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96905       };
96906     }
96907   }
96908 }
96909
96910
96911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
96912   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96913   uint16_t arg2 ;
96914   uint16_t arg3 ;
96915   uint16_t arg4 ;
96916   uint16_t arg5 ;
96917
96918   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96919   arg2 = (uint16_t)jarg2;
96920   arg3 = (uint16_t)jarg3;
96921   arg4 = (uint16_t)jarg4;
96922   arg5 = (uint16_t)jarg5;
96923   {
96924     try {
96925       (arg1)->Crop(arg2,arg3,arg4,arg5);
96926     } catch (std::out_of_range& e) {
96927       {
96928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96929       };
96930     } catch (std::exception& e) {
96931       {
96932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96933       };
96934     } catch (...) {
96935       {
96936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96937       };
96938     }
96939   }
96940 }
96941
96942
96943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
96944   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96945   uint16_t arg2 ;
96946   uint16_t arg3 ;
96947
96948   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96949   arg2 = (uint16_t)jarg2;
96950   arg3 = (uint16_t)jarg3;
96951   {
96952     try {
96953       (arg1)->Resize(arg2,arg3);
96954     } catch (std::out_of_range& e) {
96955       {
96956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96957       };
96958     } catch (std::exception& e) {
96959       {
96960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96961       };
96962     } catch (...) {
96963       {
96964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96965       };
96966     }
96967   }
96968 }
96969
96970 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void * jarg2) {
96971   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96972   Dali::Degree * arg2 ;
96973
96974   bool result = false;
96975
96976   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96977   arg2 = (Dali::Degree *)jarg2;
96978   {
96979     try {
96980       result = (arg1)->Rotate(*arg2);
96981     } catch (std::out_of_range& e) {
96982       {
96983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
96984       };
96985     } catch (std::exception& e) {
96986       {
96987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
96988       };
96989     } catch (...) {
96990       {
96991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
96992       };
96993     }
96994   }
96995   return result;
96996 }
96997
96998
96999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97000   void * jresult ;
97001   std::string *arg1 = 0 ;
97002   Dali::ImageDimensions arg2 ;
97003   Dali::FittingMode::Type arg3 ;
97004   Dali::SamplingMode::Type arg4 ;
97005   bool arg5 ;
97006   Dali::ImageDimensions *argp2 ;
97007   Dali::Devel::PixelBuffer result;
97008
97009   if (!jarg1) {
97010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97011     return 0;
97012   }
97013   std::string arg1_str(jarg1);
97014   arg1 = &arg1_str;
97015   argp2 = (Dali::ImageDimensions *)jarg2;
97016   if (!argp2) {
97017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97018     return 0;
97019   }
97020   arg2 = *argp2;
97021   arg3 = (Dali::FittingMode::Type)jarg3;
97022   arg4 = (Dali::SamplingMode::Type)jarg4;
97023   arg5 = jarg5 ? true : false;
97024   {
97025     try {
97026       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97027     } catch (std::out_of_range& e) {
97028       {
97029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97030       };
97031     } catch (std::exception& e) {
97032       {
97033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97034       };
97035     } catch (...) {
97036       {
97037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97038       };
97039     }
97040   }
97041   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97042
97043   return jresult;
97044 }
97045
97046
97047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97048   void * jresult ;
97049   std::string *arg1 = 0 ;
97050   Dali::ImageDimensions arg2 ;
97051   Dali::FittingMode::Type arg3 ;
97052   Dali::SamplingMode::Type arg4 ;
97053   Dali::ImageDimensions *argp2 ;
97054   Dali::Devel::PixelBuffer result;
97055
97056   if (!jarg1) {
97057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97058     return 0;
97059   }
97060   std::string arg1_str(jarg1);
97061   arg1 = &arg1_str;
97062   argp2 = (Dali::ImageDimensions *)jarg2;
97063   if (!argp2) {
97064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97065     return 0;
97066   }
97067   arg2 = *argp2;
97068   arg3 = (Dali::FittingMode::Type)jarg3;
97069   arg4 = (Dali::SamplingMode::Type)jarg4;
97070   {
97071     try {
97072       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
97073     } catch (std::out_of_range& e) {
97074       {
97075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97076       };
97077     } catch (std::exception& e) {
97078       {
97079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97080       };
97081     } catch (...) {
97082       {
97083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97084       };
97085     }
97086   }
97087   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97088
97089   return jresult;
97090 }
97091
97092
97093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97094   void * jresult ;
97095   std::string *arg1 = 0 ;
97096   Dali::ImageDimensions arg2 ;
97097   Dali::FittingMode::Type arg3 ;
97098   Dali::ImageDimensions *argp2 ;
97099   Dali::Devel::PixelBuffer result;
97100
97101   if (!jarg1) {
97102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97103     return 0;
97104   }
97105   std::string arg1_str(jarg1);
97106   arg1 = &arg1_str;
97107   argp2 = (Dali::ImageDimensions *)jarg2;
97108   if (!argp2) {
97109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97110     return 0;
97111   }
97112   arg2 = *argp2;
97113   arg3 = (Dali::FittingMode::Type)jarg3;
97114   {
97115     try {
97116       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
97117     } catch (std::out_of_range& e) {
97118       {
97119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97120       };
97121     } catch (std::exception& e) {
97122       {
97123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97124       };
97125     } catch (...) {
97126       {
97127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97128       };
97129     }
97130   }
97131   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97132
97133   return jresult;
97134 }
97135
97136
97137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
97138   void * jresult ;
97139   std::string *arg1 = 0 ;
97140   Dali::ImageDimensions arg2 ;
97141   Dali::ImageDimensions *argp2 ;
97142   Dali::Devel::PixelBuffer result;
97143
97144   if (!jarg1) {
97145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97146     return 0;
97147   }
97148   std::string arg1_str(jarg1);
97149   arg1 = &arg1_str;
97150   argp2 = (Dali::ImageDimensions *)jarg2;
97151   if (!argp2) {
97152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97153     return 0;
97154   }
97155   arg2 = *argp2;
97156   {
97157     try {
97158       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
97159     } catch (std::out_of_range& e) {
97160       {
97161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97162       };
97163     } catch (std::exception& e) {
97164       {
97165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97166       };
97167     } catch (...) {
97168       {
97169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97170       };
97171     }
97172   }
97173   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97174
97175   return jresult;
97176 }
97177
97178
97179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
97180   void * jresult ;
97181   std::string *arg1 = 0 ;
97182   Dali::Devel::PixelBuffer result;
97183
97184   if (!jarg1) {
97185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97186     return 0;
97187   }
97188   std::string arg1_str(jarg1);
97189   arg1 = &arg1_str;
97190   {
97191     try {
97192       result = Dali::LoadImageFromFile((std::string const &)*arg1);
97193     } catch (std::out_of_range& e) {
97194       {
97195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97196       };
97197     } catch (std::exception& e) {
97198       {
97199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97200       };
97201     } catch (...) {
97202       {
97203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97204       };
97205     }
97206   }
97207   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97208
97209   return jresult;
97210 }
97211
97212
97213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97214   void * jresult ;
97215   std::string *arg1 = 0 ;
97216   Dali::ImageDimensions arg2 ;
97217   Dali::FittingMode::Type arg3 ;
97218   Dali::SamplingMode::Type arg4 ;
97219   bool arg5 ;
97220   Dali::ImageDimensions *argp2 ;
97221   Dali::ImageDimensions result;
97222
97223   if (!jarg1) {
97224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97225     return 0;
97226   }
97227   std::string arg1_str(jarg1);
97228   arg1 = &arg1_str;
97229   argp2 = (Dali::ImageDimensions *)jarg2;
97230   if (!argp2) {
97231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97232     return 0;
97233   }
97234   arg2 = *argp2;
97235   arg3 = (Dali::FittingMode::Type)jarg3;
97236   arg4 = (Dali::SamplingMode::Type)jarg4;
97237   arg5 = jarg5 ? true : false;
97238   {
97239     try {
97240       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97241     } catch (std::out_of_range& e) {
97242       {
97243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97244       };
97245     } catch (std::exception& e) {
97246       {
97247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97248       };
97249     } catch (...) {
97250       {
97251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97252       };
97253     }
97254   }
97255   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97256
97257   return jresult;
97258 }
97259
97260
97261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97262   void * jresult ;
97263   std::string *arg1 = 0 ;
97264   Dali::ImageDimensions arg2 ;
97265   Dali::FittingMode::Type arg3 ;
97266   Dali::SamplingMode::Type arg4 ;
97267   Dali::ImageDimensions *argp2 ;
97268   Dali::ImageDimensions result;
97269
97270   if (!jarg1) {
97271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97272     return 0;
97273   }
97274   std::string arg1_str(jarg1);
97275   arg1 = &arg1_str;
97276   argp2 = (Dali::ImageDimensions *)jarg2;
97277   if (!argp2) {
97278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97279     return 0;
97280   }
97281   arg2 = *argp2;
97282   arg3 = (Dali::FittingMode::Type)jarg3;
97283   arg4 = (Dali::SamplingMode::Type)jarg4;
97284   {
97285     try {
97286       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
97287     } catch (std::out_of_range& e) {
97288       {
97289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97290       };
97291     } catch (std::exception& e) {
97292       {
97293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97294       };
97295     } catch (...) {
97296       {
97297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97298       };
97299     }
97300   }
97301   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97302
97303   return jresult;
97304 }
97305
97306
97307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97308   void * jresult ;
97309   std::string *arg1 = 0 ;
97310   Dali::ImageDimensions arg2 ;
97311   Dali::FittingMode::Type arg3 ;
97312   Dali::ImageDimensions *argp2 ;
97313   Dali::ImageDimensions result;
97314
97315   if (!jarg1) {
97316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97317     return 0;
97318   }
97319   std::string arg1_str(jarg1);
97320   arg1 = &arg1_str;
97321   argp2 = (Dali::ImageDimensions *)jarg2;
97322   if (!argp2) {
97323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97324     return 0;
97325   }
97326   arg2 = *argp2;
97327   arg3 = (Dali::FittingMode::Type)jarg3;
97328   {
97329     try {
97330       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
97331     } catch (std::out_of_range& e) {
97332       {
97333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97334       };
97335     } catch (std::exception& e) {
97336       {
97337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97338       };
97339     } catch (...) {
97340       {
97341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97342       };
97343     }
97344   }
97345   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97346
97347   return jresult;
97348 }
97349
97350
97351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
97352   void * jresult ;
97353   std::string *arg1 = 0 ;
97354   Dali::ImageDimensions arg2 ;
97355   Dali::ImageDimensions *argp2 ;
97356   Dali::ImageDimensions result;
97357
97358   if (!jarg1) {
97359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97360     return 0;
97361   }
97362   std::string arg1_str(jarg1);
97363   arg1 = &arg1_str;
97364   argp2 = (Dali::ImageDimensions *)jarg2;
97365   if (!argp2) {
97366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97367     return 0;
97368   }
97369   arg2 = *argp2;
97370   {
97371     try {
97372       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
97373     } catch (std::out_of_range& e) {
97374       {
97375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97376       };
97377     } catch (std::exception& e) {
97378       {
97379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97380       };
97381     } catch (...) {
97382       {
97383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97384       };
97385     }
97386   }
97387   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97388
97389   return jresult;
97390 }
97391
97392
97393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
97394   void * jresult ;
97395   std::string *arg1 = 0 ;
97396   Dali::ImageDimensions result;
97397
97398   if (!jarg1) {
97399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97400     return 0;
97401   }
97402   std::string arg1_str(jarg1);
97403   arg1 = &arg1_str;
97404   {
97405     try {
97406       result = Dali::GetClosestImageSize((std::string const &)*arg1);
97407     } catch (std::out_of_range& e) {
97408       {
97409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97410       };
97411     } catch (std::exception& e) {
97412       {
97413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97414       };
97415     } catch (...) {
97416       {
97417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97418       };
97419     }
97420   }
97421   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97422
97423   return jresult;
97424 }
97425
97426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
97427   void * jresult ;
97428   std::string *arg1 = 0 ;
97429   Dali::ImageDimensions result;
97430
97431   if (!jarg1) {
97432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97433     return 0;
97434   }
97435   std::string arg1_str(jarg1);
97436   arg1 = &arg1_str;
97437   {
97438     try {
97439       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
97440     } catch (std::out_of_range& e) {
97441       {
97442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97443       };
97444     } catch (std::exception& e) {
97445       {
97446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97447       };
97448     } catch (...) {
97449       {
97450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97451       };
97452     }
97453   }
97454   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97455
97456   return jresult;
97457 }
97458
97459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97460   void * jresult ;
97461   std::string *arg1 = 0 ;
97462   Dali::ImageDimensions arg2 ;
97463   Dali::FittingMode::Type arg3 ;
97464   Dali::SamplingMode::Type arg4 ;
97465   bool arg5 ;
97466   Dali::ImageDimensions *argp2 ;
97467   Dali::Devel::PixelBuffer result;
97468
97469   if (!jarg1) {
97470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97471     return 0;
97472   }
97473   std::string arg1_str(jarg1);
97474   arg1 = &arg1_str;
97475   argp2 = (Dali::ImageDimensions *)jarg2;
97476   if (!argp2) {
97477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97478     return 0;
97479   }
97480   arg2 = *argp2;
97481   arg3 = (Dali::FittingMode::Type)jarg3;
97482   arg4 = (Dali::SamplingMode::Type)jarg4;
97483   arg5 = jarg5 ? true : false;
97484   {
97485     try {
97486       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97487     } catch (std::out_of_range& e) {
97488       {
97489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97490       };
97491     } catch (std::exception& e) {
97492       {
97493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97494       };
97495     } catch (...) {
97496       {
97497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97498       };
97499     }
97500   }
97501   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97502
97503   return jresult;
97504 }
97505
97506
97507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97508   void * jresult ;
97509   std::string *arg1 = 0 ;
97510   Dali::ImageDimensions arg2 ;
97511   Dali::FittingMode::Type arg3 ;
97512   Dali::SamplingMode::Type arg4 ;
97513   Dali::ImageDimensions *argp2 ;
97514   Dali::Devel::PixelBuffer result;
97515
97516   if (!jarg1) {
97517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97518     return 0;
97519   }
97520   std::string arg1_str(jarg1);
97521   arg1 = &arg1_str;
97522   argp2 = (Dali::ImageDimensions *)jarg2;
97523   if (!argp2) {
97524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97525     return 0;
97526   }
97527   arg2 = *argp2;
97528   arg3 = (Dali::FittingMode::Type)jarg3;
97529   arg4 = (Dali::SamplingMode::Type)jarg4;
97530   {
97531     try {
97532       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
97533     } catch (std::out_of_range& e) {
97534       {
97535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97536       };
97537     } catch (std::exception& e) {
97538       {
97539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97540       };
97541     } catch (...) {
97542       {
97543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97544       };
97545     }
97546   }
97547   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97548
97549   return jresult;
97550 }
97551
97552
97553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97554   void * jresult ;
97555   std::string *arg1 = 0 ;
97556   Dali::ImageDimensions arg2 ;
97557   Dali::FittingMode::Type arg3 ;
97558   Dali::ImageDimensions *argp2 ;
97559   Dali::Devel::PixelBuffer result;
97560
97561   if (!jarg1) {
97562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97563     return 0;
97564   }
97565   std::string arg1_str(jarg1);
97566   arg1 = &arg1_str;
97567   argp2 = (Dali::ImageDimensions *)jarg2;
97568   if (!argp2) {
97569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97570     return 0;
97571   }
97572   arg2 = *argp2;
97573   arg3 = (Dali::FittingMode::Type)jarg3;
97574   {
97575     try {
97576       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
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_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
97598   void * jresult ;
97599   std::string *arg1 = 0 ;
97600   Dali::ImageDimensions arg2 ;
97601   Dali::ImageDimensions *argp2 ;
97602   Dali::Devel::PixelBuffer result;
97603
97604   if (!jarg1) {
97605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97606     return 0;
97607   }
97608   std::string arg1_str(jarg1);
97609   arg1 = &arg1_str;
97610   argp2 = (Dali::ImageDimensions *)jarg2;
97611   if (!argp2) {
97612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97613     return 0;
97614   }
97615   arg2 = *argp2;
97616   {
97617     try {
97618       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
97619     } catch (std::out_of_range& e) {
97620       {
97621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97622       };
97623     } catch (std::exception& e) {
97624       {
97625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97626       };
97627     } catch (...) {
97628       {
97629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97630       };
97631     }
97632   }
97633   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97634
97635   return jresult;
97636 }
97637
97638
97639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
97640   void * jresult ;
97641   std::string *arg1 = 0 ;
97642   Dali::Devel::PixelBuffer result;
97643
97644   if (!jarg1) {
97645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97646     return 0;
97647   }
97648   std::string arg1_str(jarg1);
97649   arg1 = &arg1_str;
97650   {
97651     try {
97652       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
97653     } catch (std::out_of_range& e) {
97654       {
97655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97656       };
97657     } catch (std::exception& e) {
97658       {
97659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97660       };
97661     } catch (...) {
97662       {
97663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97664       };
97665     }
97666   }
97667   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97668
97669   return jresult;
97670 }
97671
97672
97673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
97674   void * jresult ;
97675   Dali::Toolkit::WebView result;
97676
97677   {
97678     try {
97679       result = Dali::Toolkit::WebView::New();
97680     } catch (std::out_of_range& e) {
97681       {
97682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97683       };
97684     } catch (std::exception& e) {
97685       {
97686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97687       };
97688     } catch (Dali::DaliException e) {
97689       {
97690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97691       };
97692     } catch (...) {
97693       {
97694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97695       };
97696     }
97697   }
97698   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
97699   return jresult;
97700 }
97701
97702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
97703   void * jresult ;
97704   Dali::Toolkit::WebView result;
97705
97706   std::string *arg1;
97707   std::string *arg2;
97708
97709   if (!jarg1) {
97710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
97711     return 0;
97712   }
97713   if (!jarg2) {
97714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
97715     return 0;
97716   }
97717
97718   std::string jarg1_str = std::string(jarg1);
97719   std::string jarg2_str = std::string(jarg2);
97720
97721   arg1 = &jarg1_str;
97722   arg2 = &jarg2_str;
97723
97724   {
97725     try {
97726       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
97727     } catch (std::out_of_range& e) {
97728       {
97729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97730       };
97731     } catch (std::exception& e) {
97732       {
97733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97734       };
97735     } catch (Dali::DaliException e) {
97736       {
97737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97738       };
97739     } catch (...) {
97740       {
97741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97742       };
97743     }
97744   }
97745   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
97746   return jresult;
97747 }
97748
97749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
97750   void * jresult ;
97751   Dali::Toolkit::WebView *arg1 = 0 ;
97752   Dali::Toolkit::WebView *result = 0 ;
97753
97754   arg1 = (Dali::Toolkit::WebView *)jarg1;
97755   if (!arg1) {
97756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
97757     return 0;
97758   }
97759   {
97760     try {
97761       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
97762     } catch (std::out_of_range& e) {
97763       {
97764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97765       };
97766     } catch (std::exception& e) {
97767       {
97768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97769       };
97770     } catch (Dali::DaliException e) {
97771       {
97772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97773       };
97774     } catch (...) {
97775       {
97776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97777       };
97778     }
97779   }
97780   jresult = (void *)result;
97781   return jresult;
97782 }
97783
97784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
97785   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
97786   arg1 = (Dali::Toolkit::WebView *)jarg1;
97787   {
97788     try {
97789       delete arg1;
97790     } catch (std::out_of_range& e) {
97791       {
97792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97793       };
97794     } catch (std::exception& e) {
97795       {
97796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97797       };
97798     } catch (Dali::DaliException e) {
97799       {
97800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97801       };
97802     } catch (...) {
97803       {
97804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97805       };
97806     }
97807   }
97808 }
97809
97810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
97811   void * jresult ;
97812   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
97813   Dali::Toolkit::WebView *arg2 = 0 ;
97814   Dali::Toolkit::WebView *result = 0 ;
97815
97816   arg1 = (Dali::Toolkit::WebView *)jarg1;
97817   arg2 = (Dali::Toolkit::WebView *)jarg2;
97818   if (!arg2) {
97819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
97820     return 0;
97821   }
97822   {
97823     try {
97824       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
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 (Dali::DaliException e) {
97834       {
97835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97836       };
97837     } catch (...) {
97838       {
97839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97840       };
97841     }
97842   }
97843   jresult = (void *)result;
97844   return jresult;
97845 }
97846
97847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
97848   void * jresult ;
97849   Dali::BaseHandle arg1 ;
97850   Dali::BaseHandle *argp1 ;
97851   Dali::Toolkit::WebView result;
97852
97853   argp1 = (Dali::BaseHandle *)jarg1;
97854   if (!argp1) {
97855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
97856     return 0;
97857   }
97858   arg1 = *argp1;
97859   {
97860     try {
97861       result = Dali::Toolkit::WebView::DownCast(arg1);
97862     } catch (std::out_of_range& e) {
97863       {
97864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97865       };
97866     } catch (std::exception& e) {
97867       {
97868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97869       };
97870     } catch (Dali::DaliException e) {
97871       {
97872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97873       };
97874     } catch (...) {
97875       {
97876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97877       };
97878     }
97879   }
97880   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
97881   return jresult;
97882 }
97883
97884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
97885   return (int) Dali::Toolkit::WebView::Property::URL;
97886 }
97887
97888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
97889   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
97890 }
97891
97892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
97893   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
97894 }
97895
97896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
97897   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
97898 }
97899
97900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
97901   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
97902 }
97903
97904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
97905   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
97906 }
97907
97908 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
97909   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
97910 }
97911
97912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
97913   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
97914 }
97915
97916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
97917   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
97918   std::string *arg2;
97919
97920   arg1 = (Dali::Toolkit::WebView *)jarg1;
97921
97922   if (!jarg2) {
97923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97924     return;
97925   }
97926
97927   std::string jarg2str = std::string(jarg2);
97928   arg2 = &jarg2str;
97929   {
97930     try {
97931       (arg1)->LoadUrl((std::string const &)*arg2);
97932     } catch (std::out_of_range& e) {
97933       {
97934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97935       };
97936     } catch (std::exception& e) {
97937       {
97938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97939       };
97940     } catch (Dali::DaliException e) {
97941       {
97942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97943       };
97944     } catch (...) {
97945       {
97946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97947       };
97948     }
97949   }
97950 }
97951
97952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
97953   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
97954   std::string *arg2;
97955
97956   arg1 = (Dali::Toolkit::WebView *)jarg1;
97957   if (!jarg2) {
97958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97959     return;
97960   }
97961   std::string jarg2str = std::string(jarg2);
97962   arg2 = &jarg2str;
97963   {
97964     try {
97965       (arg1)->LoadHTMLString((std::string const &)*arg2);
97966     } catch (std::out_of_range& e) {
97967       {
97968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97969       };
97970     } catch (std::exception& e) {
97971       {
97972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97973       };
97974     } catch (Dali::DaliException e) {
97975       {
97976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97977       };
97978     } catch (...) {
97979       {
97980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97981       };
97982     }
97983   }
97984 }
97985
97986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
97987   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
97988
97989   arg1 = (Dali::Toolkit::WebView *)jarg1;
97990   {
97991     try {
97992       (arg1)->Reload();
97993     } catch (std::out_of_range& e) {
97994       {
97995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97996       };
97997     } catch (std::exception& e) {
97998       {
97999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98000       };
98001     } catch (Dali::DaliException e) {
98002       {
98003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98004       };
98005     } catch (...) {
98006       {
98007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98008       };
98009     }
98010   }
98011 }
98012
98013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
98014   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98015
98016   arg1 = (Dali::Toolkit::WebView *)jarg1;
98017   {
98018     try {
98019       (arg1)->StopLoading();
98020     } catch (std::out_of_range& e) {
98021       {
98022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98023       };
98024     } catch (std::exception& e) {
98025       {
98026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98027       };
98028     } catch (Dali::DaliException e) {
98029       {
98030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98031       };
98032     } catch (...) {
98033       {
98034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98035       };
98036     }
98037   }
98038 }
98039
98040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
98041   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98042
98043   arg1 = (Dali::Toolkit::WebView *)jarg1;
98044   {
98045     try {
98046       (arg1)->Suspend();
98047     } catch (std::out_of_range& e) {
98048       {
98049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98050       };
98051     } catch (std::exception& e) {
98052       {
98053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98054       };
98055     } catch (Dali::DaliException e) {
98056       {
98057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98058       };
98059     } catch (...) {
98060       {
98061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98062       };
98063     }
98064   }
98065 }
98066
98067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
98068   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98069
98070   arg1 = (Dali::Toolkit::WebView *)jarg1;
98071   {
98072     try {
98073       (arg1)->Resume();
98074     } catch (std::out_of_range& e) {
98075       {
98076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98077       };
98078     } catch (std::exception& e) {
98079       {
98080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98081       };
98082     } catch (Dali::DaliException e) {
98083       {
98084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98085       };
98086     } catch (...) {
98087       {
98088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98089       };
98090     }
98091   }
98092 }
98093
98094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
98095   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98096
98097   arg1 = (Dali::Toolkit::WebView *)jarg1;
98098   {
98099     try {
98100       (arg1)->GoBack();
98101     } catch (std::out_of_range& e) {
98102       {
98103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98104       };
98105     } catch (std::exception& e) {
98106       {
98107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98108       };
98109     } catch (Dali::DaliException e) {
98110       {
98111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98112       };
98113     } catch (...) {
98114       {
98115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98116       };
98117     }
98118   }
98119 }
98120
98121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
98122   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98123
98124   arg1 = (Dali::Toolkit::WebView *)jarg1;
98125   {
98126     try {
98127       (arg1)->GoForward();
98128     } catch (std::out_of_range& e) {
98129       {
98130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98131       };
98132     } catch (std::exception& e) {
98133       {
98134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98135       };
98136     } catch (Dali::DaliException e) {
98137       {
98138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98139       };
98140     } catch (...) {
98141       {
98142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98143       };
98144     }
98145   }
98146 }
98147
98148 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
98149   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98150   bool ret;
98151
98152   arg1 = (Dali::Toolkit::WebView *)jarg1;
98153   {
98154     try {
98155       ret = (arg1)->CanGoBack();
98156     } catch (std::out_of_range& e) {
98157       {
98158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98159       };
98160     } catch (std::exception& e) {
98161       {
98162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98163       };
98164     } catch (Dali::DaliException e) {
98165       {
98166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98167       };
98168     } catch (...) {
98169       {
98170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98171       };
98172     }
98173   }
98174   return ret;
98175 }
98176
98177 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
98178   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98179   bool ret;
98180
98181   arg1 = (Dali::Toolkit::WebView *)jarg1;
98182   {
98183     try {
98184       ret = (arg1)->CanGoForward();
98185     } catch (std::out_of_range& e) {
98186       {
98187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98188       };
98189     } catch (std::exception& e) {
98190       {
98191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98192       };
98193     } catch (Dali::DaliException e) {
98194       {
98195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98196       };
98197     } catch (...) {
98198       {
98199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98200       };
98201     }
98202   }
98203   return ret;
98204 }
98205
98206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
98207   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98208   std::string *arg2;
98209
98210   arg1 = (Dali::Toolkit::WebView *)jarg1;
98211   if (!jarg2) {
98212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98213     return;
98214   }
98215   std::string jarg2_str = std::string(jarg2);
98216   arg2 = &jarg2_str;
98217
98218   {
98219     try {
98220       if (jarg3) {
98221         void (*handler)(char*) = (void (*)(char*)) jarg3;
98222         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
98223           handler(SWIG_csharp_string_callback(result.c_str()));
98224         });
98225       } else {
98226         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
98227       }
98228     } catch (std::out_of_range& e) {
98229       {
98230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98231       };
98232     } catch (std::exception& e) {
98233       {
98234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98235       };
98236     } catch (Dali::DaliException e) {
98237       {
98238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98239       };
98240     } catch (...) {
98241       {
98242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98243       };
98244     }
98245   }
98246 }
98247
98248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
98249 {
98250   if (!jarg2) {
98251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98252     return;
98253   }
98254
98255   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98256   std::string exposedObjectName = jarg2;
98257   void (*handler)(char*) = (void (*)(char*)) jarg3;
98258
98259   {
98260     try {
98261       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
98262         handler(SWIG_csharp_string_callback(message.c_str()));
98263       });
98264     } catch (std::out_of_range& e) {
98265       {
98266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98267       };
98268     } catch (std::exception& e) {
98269       {
98270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98271       };
98272     } catch (Dali::DaliException e) {
98273       {
98274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98275       };
98276     } catch (...) {
98277       {
98278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98279       };
98280     }
98281   }
98282 }
98283
98284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
98285   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98286
98287   arg1 = (Dali::Toolkit::WebView *)jarg1;
98288   {
98289     try {
98290       (arg1)->ClearHistory();
98291     } catch (std::out_of_range& e) {
98292       {
98293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98294       };
98295     } catch (std::exception& e) {
98296       {
98297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98298       };
98299     } catch (Dali::DaliException e) {
98300       {
98301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98302       };
98303     } catch (...) {
98304       {
98305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98306       };
98307     }
98308   }
98309 }
98310
98311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
98312   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98313
98314   arg1 = (Dali::Toolkit::WebView *)jarg1;
98315   {
98316     try {
98317       (arg1)->ClearCache();
98318     } catch (std::out_of_range& e) {
98319       {
98320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98321       };
98322     } catch (std::exception& e) {
98323       {
98324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98325       };
98326     } catch (Dali::DaliException e) {
98327       {
98328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98329       };
98330     } catch (...) {
98331       {
98332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98333       };
98334     }
98335   }
98336 }
98337
98338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
98339   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98340
98341   arg1 = (Dali::Toolkit::WebView *)jarg1;
98342   {
98343     try {
98344       (arg1)->ClearCookies();
98345     } catch (std::out_of_range& e) {
98346       {
98347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98348       };
98349     } catch (std::exception& e) {
98350       {
98351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98352       };
98353     } catch (Dali::DaliException e) {
98354       {
98355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98356       };
98357     } catch (...) {
98358       {
98359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98360       };
98361     }
98362   }
98363 }
98364
98365 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
98366     return (Dali::Toolkit::Control *)jarg1;
98367 }
98368
98369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
98370   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98371   SignalConverter::WebViewPageLoadSignal* result = NULL;
98372   {
98373     try {
98374       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
98375     } catch (std::out_of_range& e) {
98376       {
98377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98378       };
98379     } catch (std::exception& e) {
98380       {
98381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98382       };
98383     } catch (Dali::DaliException e) {
98384       {
98385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98386       };
98387     } catch (...) {
98388       {
98389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98390       };
98391     }
98392   }
98393   return (void*) result;
98394 }
98395
98396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
98397   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98398   SignalConverter::WebViewPageLoadSignal* result = NULL;
98399   {
98400     try {
98401       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
98402     } catch (std::out_of_range& e) {
98403       {
98404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98405       };
98406     } catch (std::exception& e) {
98407       {
98408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98409       };
98410     } catch (Dali::DaliException e) {
98411       {
98412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98413       };
98414     } catch (...) {
98415       {
98416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98417       };
98418     }
98419   }
98420   return (void*) result;
98421 }
98422
98423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
98424 {
98425   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98426   {
98427     try {
98428       delete object;
98429     } catch (std::out_of_range& e) {
98430       {
98431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98432       };
98433     } catch (std::exception& e) {
98434       {
98435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98436       };
98437     } catch (Dali::DaliException e) {
98438       {
98439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98440       };
98441     } catch (...) {
98442       {
98443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98444       };
98445     }
98446   }
98447 }
98448
98449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
98450 {
98451   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98452   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98453   {
98454     try {
98455       proxy->Connect(callback);
98456     } catch (std::out_of_range& e) {
98457       {
98458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98459       };
98460     } catch (std::exception& e) {
98461       {
98462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98463       };
98464     } catch (Dali::DaliException e) {
98465       {
98466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98467       };
98468     } catch (...) {
98469       {
98470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98471       };
98472     }
98473   }
98474 }
98475
98476
98477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
98478   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98479   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98480   {
98481     try {
98482       proxy->Disconnect(callback);
98483     } catch (std::out_of_range& e) {
98484       {
98485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98486       };
98487     } catch (std::exception& e) {
98488       {
98489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98490       };
98491     } catch (Dali::DaliException e) {
98492       {
98493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98494       };
98495     } catch (...) {
98496       {
98497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98498       };
98499     }
98500   }
98501 }
98502
98503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
98504   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98505   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
98506   {
98507     try {
98508       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
98509     } catch (std::out_of_range& e) {
98510       {
98511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98512       };
98513     } catch (std::exception& e) {
98514       {
98515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98516       };
98517     } catch (Dali::DaliException e) {
98518       {
98519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98520       };
98521     } catch (...) {
98522       {
98523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98524       };
98525     }
98526   }
98527   return (void*) result;
98528 }
98529
98530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
98531 {
98532   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98533   {
98534     try {
98535       delete object;
98536     } catch (std::out_of_range& e) {
98537       {
98538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98539       };
98540     } catch (std::exception& e) {
98541       {
98542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98543       };
98544     } catch (Dali::DaliException e) {
98545       {
98546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98547       };
98548     } catch (...) {
98549       {
98550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98551       };
98552     }
98553   }
98554 }
98555
98556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
98557 {
98558   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98559   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
98560   {
98561     try {
98562       proxy->Connect(callback);
98563     } catch (std::out_of_range& e) {
98564       {
98565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98566       };
98567     } catch (std::exception& e) {
98568       {
98569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98570       };
98571     } catch (Dali::DaliException e) {
98572       {
98573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98574       };
98575     } catch (...) {
98576       {
98577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98578       };
98579     }
98580   }
98581 }
98582
98583
98584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
98585   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98586   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
98587   {
98588     try {
98589       proxy->Disconnect(callback);
98590     } catch (std::out_of_range& e) {
98591       {
98592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98593       };
98594     } catch (std::exception& e) {
98595       {
98596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98597       };
98598     } catch (Dali::DaliException e) {
98599       {
98600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98601       };
98602     } catch (...) {
98603       {
98604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98605       };
98606     }
98607   }
98608 }
98609
98610 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
98611   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
98612   char * jresult = SWIG_csharp_string_callback((const char *)result);
98613   return jresult;
98614 }
98615
98616 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
98617   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
98618   return result;
98619 }
98620
98621
98622 struct NativeImageSourcePtrHandle
98623 {
98624   NativeImageSourcePtr Ptr;
98625 };
98626
98627 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
98628 {
98629   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98630   return (NativeImageInterface*)(arg1);
98631 }
98632
98633 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
98634 {
98635   void* jresult;
98636   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
98637   {
98638     try {
98639       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
98640     }
98641     catch (std::out_of_range & e) {
98642       {
98643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98644       };
98645     }
98646     catch (std::exception & e) {
98647       {
98648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98649       };
98650     }
98651     catch (Dali::DaliException e) {
98652       {
98653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98654       };
98655     }
98656     catch (...) {
98657       {
98658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98659       };
98660     }
98661   }
98662   jresult = (void *)handle;
98663   return jresult;
98664 }
98665
98666 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
98667 {
98668   void* jresult;
98669   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
98670   jresult = (void*)( handle->Ptr.Get() );
98671   return jresult;
98672 }
98673
98674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
98675   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
98676   {
98677     try {
98678       delete arg1;
98679     }
98680     catch (std::out_of_range & e) {
98681       {
98682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
98683       };
98684     }
98685     catch (std::exception & e) {
98686       {
98687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
98688       };
98689     }
98690     catch (Dali::DaliException e) {
98691       {
98692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
98693       };
98694     }
98695     catch (...) {
98696       {
98697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
98698       };
98699     }
98700   }
98701 }
98702
98703 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
98704 {
98705   void* jresult;
98706   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98707   uint16_t* arg2 = (uint16_t*)(jarg2);
98708   uint16_t* arg3 = (uint16_t*)(jarg3);
98709   uint16_t* arg4 = (uint16_t*)(jarg4);
98710   {
98711     try {
98712       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
98713     }
98714     catch (std::out_of_range & e) {
98715       {
98716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98717       };
98718     }
98719     catch (std::exception & e) {
98720       {
98721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98722       };
98723     }
98724     catch (Dali::DaliException e) {
98725       {
98726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98727       };
98728     }
98729     catch (...) {
98730       {
98731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98732       };
98733     }
98734   }
98735   return jresult;
98736 }
98737
98738 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
98739 {
98740   bool jresult;
98741   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98742
98743   {
98744     try {
98745       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
98746     }
98747     catch (std::out_of_range & e) {
98748       {
98749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98750       };
98751     }
98752     catch (std::exception & e) {
98753       {
98754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98755       };
98756     }
98757     catch (Dali::DaliException e) {
98758       {
98759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98760       };
98761     }
98762     catch (...) {
98763       {
98764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98765       };
98766     }
98767   }
98768   return jresult;
98769 }
98770
98771
98772 #ifdef __cplusplus
98773 }
98774 #endif