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_VertexBuffer_New(void * jarg1) {
25184   void * jresult ;
25185   Dali::Property::Map *arg1 = 0 ;
25186   Dali::VertexBuffer 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::VertexBuffer::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::VertexBuffer((const Dali::VertexBuffer &)result);
25216   return jresult;
25217 }
25218
25219
25220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VertexBuffer__SWIG_0() {
25221   void * jresult ;
25222   Dali::VertexBuffer *result = 0 ;
25223
25224   {
25225     try {
25226       result = (Dali::VertexBuffer *)new Dali::VertexBuffer();
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_VertexBuffer(void * jarg1) {
25252   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
25253
25254   arg1 = (Dali::VertexBuffer *)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_VertexBuffer__SWIG_1(void * jarg1) {
25281   void * jresult ;
25282   Dali::VertexBuffer *arg1 = 0 ;
25283   Dali::VertexBuffer *result = 0 ;
25284
25285   arg1 = (Dali::VertexBuffer *)jarg1;
25286   if (!arg1) {
25287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
25288     return 0;
25289   }
25290   {
25291     try {
25292       result = (Dali::VertexBuffer *)new Dali::VertexBuffer((Dali::VertexBuffer 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_VertexBuffer_DownCast(void * jarg1) {
25318   void * jresult ;
25319   Dali::BaseHandle arg1 ;
25320   Dali::BaseHandle *argp1 ;
25321   Dali::VertexBuffer 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::VertexBuffer::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::VertexBuffer((const Dali::VertexBuffer &)result);
25352   return jresult;
25353 }
25354
25355
25356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VertexBuffer_Assign(void * jarg1, void * jarg2) {
25357   void * jresult ;
25358   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
25359   Dali::VertexBuffer *arg2 = 0 ;
25360   Dali::VertexBuffer *result = 0 ;
25361
25362   arg1 = (Dali::VertexBuffer *)jarg1;
25363   arg2 = (Dali::VertexBuffer *)jarg2;
25364   if (!arg2) {
25365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer const & type is null", 0);
25366     return 0;
25367   }
25368   {
25369     try {
25370       result = (Dali::VertexBuffer *) &(arg1)->operator =((Dali::VertexBuffer 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_VertexBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25396   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
25397   void *arg2 = (void *) 0 ;
25398   std::size_t arg3 ;
25399
25400   arg1 = (Dali::VertexBuffer *)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_VertexBuffer_GetSize(void * jarg1) {
25429   unsigned long jresult ;
25430   Dali::VertexBuffer *arg1 = (Dali::VertexBuffer *) 0 ;
25431   std::size_t result;
25432
25433   arg1 = (Dali::VertexBuffer *)jarg1;
25434   {
25435     try {
25436       result = ((Dali::VertexBuffer 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::VertexBuffer *arg2 = 0 ;
25671   std::size_t result;
25672
25673   arg1 = (Dali::Geometry *)jarg1;
25674   arg2 = (Dali::VertexBuffer *)jarg2;
25675   if (!arg2) {
25676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::VertexBuffer & 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(void * jarg1) {
30523   void * jresult ;
30524   Dali::HoverEvent *arg1 = 0 ;
30525   Dali::HoverEvent *result = 0 ;
30526
30527   arg1 = (Dali::HoverEvent *)jarg1;
30528   if (!arg1) {
30529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
30530     return 0;
30531   }
30532   {
30533     try {
30534       result = (Dali::HoverEvent *)new Dali::HoverEvent((Dali::HoverEvent const &)*arg1);
30535     } catch (std::out_of_range& e) {
30536       {
30537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30538       };
30539     } catch (std::exception& e) {
30540       {
30541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30542       };
30543     } catch (Dali::DaliException e) {
30544       {
30545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30546       };
30547     } catch (...) {
30548       {
30549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30550       };
30551     }
30552   }
30553
30554   jresult = (void *)result;
30555   return jresult;
30556 }
30557
30558
30559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30560   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30561
30562   arg1 = (Dali::HoverEvent *)jarg1;
30563   {
30564     try {
30565       delete arg1;
30566     } catch (std::out_of_range& e) {
30567       {
30568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30569       };
30570     } catch (std::exception& e) {
30571       {
30572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30573       };
30574     } catch (Dali::DaliException e) {
30575       {
30576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30577       };
30578     } catch (...) {
30579       {
30580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30581       };
30582     }
30583   }
30584
30585 }
30586
30587
30588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_Assign(void * jarg1, void * jarg2) {
30589   void * jresult ;
30590   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30591   Dali::HoverEvent *arg2 = 0 ;
30592   Dali::HoverEvent *result = 0 ;
30593
30594   arg1 = (Dali::HoverEvent *)jarg1;
30595   arg2 = (Dali::HoverEvent *)jarg2;
30596   if (!arg2) {
30597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
30598     return 0;
30599   }
30600   {
30601     try {
30602       result = (Dali::HoverEvent *) &(arg1)->operator =((Dali::HoverEvent const &)*arg2);
30603     } catch (std::out_of_range& e) {
30604       {
30605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30606       };
30607     } catch (std::exception& e) {
30608       {
30609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30610       };
30611     } catch (Dali::DaliException e) {
30612       {
30613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30614       };
30615     } catch (...) {
30616       {
30617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30618       };
30619     }
30620   }
30621
30622   jresult = (void *)result;
30623   return jresult;
30624 }
30625
30626
30627 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetTime(void * jarg1) {
30628   unsigned long jresult ;
30629   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30630   unsigned long result;
30631
30632   arg1 = (Dali::HoverEvent *)jarg1;
30633   {
30634     try {
30635       result = (unsigned long)((Dali::HoverEvent const *)arg1)->GetTime();
30636     } catch (std::out_of_range& e) {
30637       {
30638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30639       };
30640     } catch (std::exception& e) {
30641       {
30642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30643       };
30644     } catch (Dali::DaliException e) {
30645       {
30646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30647       };
30648     } catch (...) {
30649       {
30650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30651       };
30652     }
30653   }
30654
30655   jresult = (unsigned long)result;
30656   return jresult;
30657 }
30658
30659
30660 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30661   unsigned long jresult ;
30662   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30663   std::size_t result;
30664
30665   arg1 = (Dali::HoverEvent *)jarg1;
30666   {
30667     try {
30668       result = ((Dali::HoverEvent const *)arg1)->GetPointCount();
30669     } catch (std::out_of_range& e) {
30670       {
30671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30672       };
30673     } catch (std::exception& e) {
30674       {
30675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30676       };
30677     } catch (Dali::DaliException e) {
30678       {
30679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30680       };
30681     } catch (...) {
30682       {
30683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30684       };
30685     }
30686   }
30687
30688   jresult = (unsigned long)result;
30689   return jresult;
30690 }
30691
30692
30693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetDeviceId(void * jarg1, unsigned long jarg2) {
30694   int jresult ;
30695   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30696   std::size_t arg2 ;
30697   int32_t result;
30698
30699   arg1 = (Dali::HoverEvent *)jarg1;
30700   arg2 = (std::size_t)jarg2;
30701   {
30702     try {
30703       result = ((Dali::HoverEvent const *)arg1)->GetDeviceId(arg2);
30704     } catch (std::out_of_range& e) {
30705       {
30706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30707       };
30708     } catch (std::exception& e) {
30709       {
30710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30711       };
30712     } catch (Dali::DaliException e) {
30713       {
30714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30715       };
30716     } catch (...) {
30717       {
30718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30719       };
30720     }
30721   }
30722
30723   jresult = result;
30724   return jresult;
30725 }
30726
30727
30728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Hover_GetState(void * jarg1, unsigned long jarg2) {
30729   int jresult ;
30730   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30731   std::size_t arg2 ;
30732   Dali::PointState::Type result;
30733
30734   arg1 = (Dali::HoverEvent *)jarg1;
30735   arg2 = (std::size_t)jarg2;
30736   {
30737     try {
30738       result = (Dali::PointState::Type)((Dali::HoverEvent const *)arg1)->GetState(arg2);
30739     } catch (std::out_of_range& e) {
30740       {
30741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30742       };
30743     } catch (std::exception& e) {
30744       {
30745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30746       };
30747     } catch (Dali::DaliException e) {
30748       {
30749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30750       };
30751     } catch (...) {
30752       {
30753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30754       };
30755     }
30756   }
30757
30758   jresult = (int)result;
30759   return jresult;
30760 }
30761
30762
30763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetHitActor(void * jarg1, unsigned long jarg2) {
30764   void * jresult ;
30765   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30766   std::size_t arg2 ;
30767   Dali::Actor result;
30768
30769   arg1 = (Dali::HoverEvent *)jarg1;
30770   arg2 = (std::size_t)jarg2;
30771   {
30772     try {
30773       result = ((Dali::HoverEvent const *)arg1)->GetHitActor(arg2);
30774     } catch (std::out_of_range& e) {
30775       {
30776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30777       };
30778     } catch (std::exception& e) {
30779       {
30780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30781       };
30782     } catch (Dali::DaliException e) {
30783       {
30784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30785       };
30786     } catch (...) {
30787       {
30788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30789       };
30790     }
30791   }
30792
30793   jresult = new Dali::Actor((const Dali::Actor &)result);
30794   return jresult;
30795 }
30796
30797
30798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30799   void * jresult ;
30800   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30801   std::size_t arg2 ;
30802   Dali::Vector2 *result = 0 ;
30803
30804   arg1 = (Dali::HoverEvent *)jarg1;
30805   arg2 = (std::size_t)jarg2;
30806   {
30807     try {
30808       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetLocalPosition(arg2);
30809     } catch (std::out_of_range& e) {
30810       {
30811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30812       };
30813     } catch (std::exception& e) {
30814       {
30815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30816       };
30817     } catch (Dali::DaliException e) {
30818       {
30819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30820       };
30821     } catch (...) {
30822       {
30823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30824       };
30825     }
30826   }
30827
30828   jresult = (void *)result;
30829   return jresult;
30830 }
30831
30832
30833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30834   void * jresult ;
30835   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30836   std::size_t arg2 ;
30837   Dali::Vector2 *result = 0 ;
30838
30839   arg1 = (Dali::HoverEvent *)jarg1;
30840   arg2 = (std::size_t)jarg2;
30841   {
30842     try {
30843       result = (Dali::Vector2 *) &((Dali::HoverEvent const *)arg1)->GetScreenPosition(arg2);
30844     } catch (std::out_of_range& e) {
30845       {
30846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30847       };
30848     } catch (std::exception& e) {
30849       {
30850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30851       };
30852     } catch (Dali::DaliException e) {
30853       {
30854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30855       };
30856     } catch (...) {
30857       {
30858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30859       };
30860     }
30861   }
30862
30863   jresult = (void *)result;
30864   return jresult;
30865 }
30866
30867
30868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30869   void * jresult ;
30870   Dali::KeyEvent *result = 0 ;
30871
30872   {
30873     try {
30874       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30875     } catch (std::out_of_range& e) {
30876       {
30877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30878       };
30879     } catch (std::exception& e) {
30880       {
30881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30882       };
30883     } catch (Dali::DaliException e) {
30884       {
30885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30886       };
30887     } catch (...) {
30888       {
30889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30890       };
30891     }
30892   }
30893
30894   jresult = (void *)result;
30895   return jresult;
30896 }
30897
30898
30899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30900   void * jresult ;
30901   std::string *arg1 = 0 ;
30902   std::string *arg2 = 0 ;
30903   int arg3 ;
30904   int arg4 ;
30905   unsigned long arg5 ;
30906   Dali::KeyEvent::State *arg6 = 0 ;
30907   Dali::KeyEvent::State temp6 ;
30908   Dali::KeyEvent *result = 0 ;
30909
30910   if (!jarg1) {
30911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30912     return 0;
30913   }
30914   std::string arg1_str(jarg1);
30915   arg1 = &arg1_str;
30916   if (!jarg2) {
30917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30918     return 0;
30919   }
30920   std::string arg2_str(jarg2);
30921   arg2 = &arg2_str;
30922   arg3 = (int)jarg3;
30923   arg4 = (int)jarg4;
30924   arg5 = (unsigned long)jarg5;
30925   temp6 = (Dali::KeyEvent::State)jarg6;
30926   arg6 = &temp6;
30927   {
30928     try {
30929       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
30930     } catch (std::out_of_range& e) {
30931       {
30932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30933       };
30934     } catch (std::exception& e) {
30935       {
30936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30937       };
30938     } catch (Dali::DaliException e) {
30939       {
30940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30941       };
30942     } catch (...) {
30943       {
30944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30945       };
30946     }
30947   }
30948
30949   jresult = (void *)result;
30950
30951   //argout typemap for const std::string&
30952
30953
30954   //argout typemap for const std::string&
30955
30956   return jresult;
30957 }
30958
30959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
30960   void * jresult ;
30961   Dali::KeyEvent *arg1 = 0 ;
30962   Dali::KeyEvent *result = 0 ;
30963
30964   arg1 = (Dali::KeyEvent *)jarg1;
30965   if (!arg1) {
30966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30967     return 0;
30968   }
30969   {
30970     try {
30971       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
30972     } catch (std::out_of_range& e) {
30973       {
30974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30975       };
30976     } catch (std::exception& e) {
30977       {
30978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30979       };
30980     } catch (Dali::DaliException e) {
30981       {
30982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30983       };
30984     } catch (...) {
30985       {
30986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30987       };
30988     }
30989   }
30990
30991   jresult = (void *)result;
30992   return jresult;
30993 }
30994
30995
30996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
30997   void * jresult ;
30998   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30999   Dali::KeyEvent *arg2 = 0 ;
31000   Dali::KeyEvent *result = 0 ;
31001
31002   arg1 = (Dali::KeyEvent *)jarg1;
31003   arg2 = (Dali::KeyEvent *)jarg2;
31004   if (!arg2) {
31005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31006     return 0;
31007   }
31008   {
31009     try {
31010       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31011     } catch (std::out_of_range& e) {
31012       {
31013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31014       };
31015     } catch (std::exception& e) {
31016       {
31017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31018       };
31019     } catch (Dali::DaliException e) {
31020       {
31021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31022       };
31023     } catch (...) {
31024       {
31025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31026       };
31027     }
31028   }
31029
31030   jresult = (void *)result;
31031   return jresult;
31032 }
31033
31034
31035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31036   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31037
31038   arg1 = (Dali::KeyEvent *)jarg1;
31039   {
31040     try {
31041       delete arg1;
31042     } catch (std::out_of_range& e) {
31043       {
31044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31045       };
31046     } catch (std::exception& e) {
31047       {
31048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31049       };
31050     } catch (Dali::DaliException e) {
31051       {
31052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31053       };
31054     } catch (...) {
31055       {
31056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31057       };
31058     }
31059   }
31060
31061 }
31062
31063
31064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31065   unsigned int jresult ;
31066   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31067   bool result;
31068
31069   arg1 = (Dali::KeyEvent *)jarg1;
31070   {
31071     try {
31072       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31073     } catch (std::out_of_range& e) {
31074       {
31075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31076       };
31077     } catch (std::exception& e) {
31078       {
31079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31080       };
31081     } catch (Dali::DaliException e) {
31082       {
31083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31084       };
31085     } catch (...) {
31086       {
31087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31088       };
31089     }
31090   }
31091
31092   jresult = result;
31093   return jresult;
31094 }
31095
31096
31097 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31098   unsigned int jresult ;
31099   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31100   bool result;
31101
31102   arg1 = (Dali::KeyEvent *)jarg1;
31103   {
31104     try {
31105       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31106     } catch (std::out_of_range& e) {
31107       {
31108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31109       };
31110     } catch (std::exception& e) {
31111       {
31112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31113       };
31114     } catch (Dali::DaliException e) {
31115       {
31116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31117       };
31118     } catch (...) {
31119       {
31120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31121       };
31122     }
31123   }
31124
31125   jresult = result;
31126   return jresult;
31127 }
31128
31129
31130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31131   unsigned int jresult ;
31132   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31133   bool result;
31134
31135   arg1 = (Dali::KeyEvent *)jarg1;
31136   {
31137     try {
31138       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31139     } catch (std::out_of_range& e) {
31140       {
31141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31142       };
31143     } catch (std::exception& e) {
31144       {
31145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31146       };
31147     } catch (Dali::DaliException e) {
31148       {
31149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31150       };
31151     } catch (...) {
31152       {
31153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31154       };
31155     }
31156   }
31157
31158   jresult = result;
31159   return jresult;
31160 }
31161
31162
31163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31164   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31165   std::string *arg2 = 0 ;
31166
31167   arg1 = (Dali::KeyEvent *)jarg1;
31168   if (!jarg2) {
31169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31170     return ;
31171   }
31172   std::string arg2_str(jarg2);
31173   arg2 = &arg2_str;
31174   if (arg1) (arg1)->keyPressedName = *arg2;
31175
31176   //argout typemap for const std::string&
31177
31178 }
31179
31180
31181 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31182   char * jresult ;
31183
31184   if( jarg1 == NULL )
31185   {
31186     jresult = SWIG_csharp_string_callback( "" );
31187   }
31188   else
31189   {
31190     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31191     std::string *result = 0;
31192
31193     arg1 = ( Dali::KeyEvent * )jarg1;
31194     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31195     jresult = SWIG_csharp_string_callback( result->c_str() );
31196   }
31197
31198   return jresult;
31199 }
31200
31201
31202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31203   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31204   std::string *arg2 = 0 ;
31205
31206   arg1 = (Dali::KeyEvent *)jarg1;
31207   if (!jarg2) {
31208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31209     return ;
31210   }
31211   std::string arg2_str(jarg2);
31212   arg2 = &arg2_str;
31213   if (arg1) (arg1)->keyPressed = *arg2;
31214
31215   //argout typemap for const std::string&
31216
31217 }
31218
31219
31220 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31221   char * jresult ;
31222   if( NULL == jarg1 )
31223   {
31224     jresult = SWIG_csharp_string_callback( "" );
31225   }
31226   else
31227   {
31228     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31229     std::string *result = 0;
31230
31231     arg1 = ( Dali::KeyEvent * )jarg1;
31232     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31233     jresult = SWIG_csharp_string_callback( result->c_str() );
31234   }
31235   return jresult;
31236 }
31237
31238
31239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31240   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31241   int arg2 ;
31242
31243   arg1 = (Dali::KeyEvent *)jarg1;
31244   arg2 = (int)jarg2;
31245   if (arg1) (arg1)->keyCode = arg2;
31246 }
31247
31248
31249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31250   int jresult ;
31251   if( NULL == jarg1 )
31252   {
31253     jresult = -1;
31254   }
31255   else
31256   {
31257     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31258     int result;
31259
31260     arg1 = ( Dali::KeyEvent * )jarg1;
31261     result = (int)( ( arg1 )->keyCode );
31262     jresult = result;
31263   }
31264   return jresult;
31265 }
31266
31267
31268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31269   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31270   int arg2 ;
31271
31272   arg1 = (Dali::KeyEvent *)jarg1;
31273   arg2 = (int)jarg2;
31274   if (arg1) (arg1)->keyModifier = arg2;
31275 }
31276
31277
31278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31279   int jresult ;
31280   if( jarg1 == NULL )
31281   {
31282     jresult = -1;
31283   }
31284   else
31285   {
31286     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31287     int result;
31288
31289     arg1 = ( Dali::KeyEvent * )jarg1;
31290     result = (int)( ( arg1 )->keyModifier );
31291     jresult = result;
31292   }
31293   return jresult;
31294 }
31295
31296
31297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31298   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31299   unsigned long arg2 ;
31300
31301   arg1 = (Dali::KeyEvent *)jarg1;
31302   arg2 = (unsigned long)jarg2;
31303   if (arg1) (arg1)->time = arg2;
31304 }
31305
31306
31307 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31308   unsigned long jresult ;
31309   if( jarg1 == NULL )
31310   {
31311     jresult = 0;
31312   }
31313   else
31314   {
31315     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31316     unsigned long result;
31317
31318     arg1 = ( Dali::KeyEvent * )jarg1;
31319     result = (unsigned long)( ( arg1 )->time );
31320     jresult = (unsigned long)result;
31321   }
31322   return jresult;
31323 }
31324
31325
31326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31327   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31328   Dali::KeyEvent::State arg2 ;
31329
31330   arg1 = (Dali::KeyEvent *)jarg1;
31331   arg2 = (Dali::KeyEvent::State)jarg2;
31332   if (arg1) (arg1)->state = arg2;
31333 }
31334
31335
31336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31337   int jresult ;
31338   if( jarg1 == NULL )
31339   {
31340     jresult = -1;
31341   }
31342   else
31343   {
31344     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31345     Dali::KeyEvent::State result;
31346
31347     arg1 = ( Dali::KeyEvent * )jarg1;
31348     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31349     jresult = (int)result;
31350   }
31351   return jresult;
31352 }
31353
31354 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31355   char * jresult ;
31356   std::string result;
31357   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31358
31359   arg1 = (Dali::KeyEvent *)jarg1;
31360   if (!arg1) {
31361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31362     return 0;
31363   }
31364   {
31365     try {
31366       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31367     } catch (std::out_of_range& e) {
31368       {
31369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31370       };
31371     } catch (std::exception& e) {
31372       {
31373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31374       };
31375     } catch (Dali::DaliException e) {
31376       {
31377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31378       };
31379     } catch (...) {
31380       {
31381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31382       };
31383     }
31384
31385   }
31386
31387   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31388   return jresult;
31389 }
31390
31391
31392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31393   void * jresult ;
31394   Dali::LongPressGestureDetector *result = 0 ;
31395
31396   {
31397     try {
31398       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31399     } catch (std::out_of_range& e) {
31400       {
31401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31402       };
31403     } catch (std::exception& e) {
31404       {
31405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31406       };
31407     } catch (Dali::DaliException e) {
31408       {
31409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31410       };
31411     } catch (...) {
31412       {
31413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31414       };
31415     }
31416   }
31417
31418   jresult = (void *)result;
31419   return jresult;
31420 }
31421
31422
31423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31424   void * jresult ;
31425   Dali::LongPressGestureDetector result;
31426
31427   {
31428     try {
31429       result = Dali::LongPressGestureDetector::New();
31430     } catch (std::out_of_range& e) {
31431       {
31432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31433       };
31434     } catch (std::exception& e) {
31435       {
31436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31437       };
31438     } catch (Dali::DaliException e) {
31439       {
31440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31441       };
31442     } catch (...) {
31443       {
31444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31445       };
31446     }
31447   }
31448
31449   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31450   return jresult;
31451 }
31452
31453
31454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31455   void * jresult ;
31456   unsigned int arg1 ;
31457   Dali::LongPressGestureDetector result;
31458
31459   arg1 = (unsigned int)jarg1;
31460   {
31461     try {
31462       result = Dali::LongPressGestureDetector::New(arg1);
31463     } catch (std::out_of_range& e) {
31464       {
31465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31466       };
31467     } catch (std::exception& e) {
31468       {
31469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31470       };
31471     } catch (Dali::DaliException e) {
31472       {
31473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31474       };
31475     } catch (...) {
31476       {
31477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31478       };
31479     }
31480   }
31481
31482   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31483   return jresult;
31484 }
31485
31486
31487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31488   void * jresult ;
31489   unsigned int arg1 ;
31490   unsigned int arg2 ;
31491   Dali::LongPressGestureDetector result;
31492
31493   arg1 = (unsigned int)jarg1;
31494   arg2 = (unsigned int)jarg2;
31495   {
31496     try {
31497       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31498     } catch (std::out_of_range& e) {
31499       {
31500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31501       };
31502     } catch (std::exception& e) {
31503       {
31504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31505       };
31506     } catch (Dali::DaliException e) {
31507       {
31508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31509       };
31510     } catch (...) {
31511       {
31512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31513       };
31514     }
31515   }
31516
31517   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31518   return jresult;
31519 }
31520
31521
31522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31523   void * jresult ;
31524   Dali::BaseHandle arg1 ;
31525   Dali::BaseHandle *argp1 ;
31526   Dali::LongPressGestureDetector result;
31527
31528   argp1 = (Dali::BaseHandle *)jarg1;
31529   if (!argp1) {
31530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31531     return 0;
31532   }
31533   arg1 = *argp1;
31534   {
31535     try {
31536       result = Dali::LongPressGestureDetector::DownCast(arg1);
31537     } catch (std::out_of_range& e) {
31538       {
31539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31540       };
31541     } catch (std::exception& e) {
31542       {
31543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31544       };
31545     } catch (Dali::DaliException e) {
31546       {
31547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31548       };
31549     } catch (...) {
31550       {
31551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31552       };
31553     }
31554   }
31555
31556   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31557   return jresult;
31558 }
31559
31560
31561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31562   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31563
31564   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31565   {
31566     try {
31567       delete arg1;
31568     } catch (std::out_of_range& e) {
31569       {
31570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31571       };
31572     } catch (std::exception& e) {
31573       {
31574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31575       };
31576     } catch (Dali::DaliException e) {
31577       {
31578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31579       };
31580     } catch (...) {
31581       {
31582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31583       };
31584     }
31585   }
31586
31587 }
31588
31589
31590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31591   void * jresult ;
31592   Dali::LongPressGestureDetector *arg1 = 0 ;
31593   Dali::LongPressGestureDetector *result = 0 ;
31594
31595   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31596   if (!arg1) {
31597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31598     return 0;
31599   }
31600   {
31601     try {
31602       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31603     } catch (std::out_of_range& e) {
31604       {
31605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31606       };
31607     } catch (std::exception& e) {
31608       {
31609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31610       };
31611     } catch (Dali::DaliException e) {
31612       {
31613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31614       };
31615     } catch (...) {
31616       {
31617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31618       };
31619     }
31620   }
31621
31622   jresult = (void *)result;
31623   return jresult;
31624 }
31625
31626
31627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31628   void * jresult ;
31629   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31630   Dali::LongPressGestureDetector *arg2 = 0 ;
31631   Dali::LongPressGestureDetector *result = 0 ;
31632
31633   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31634   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31635   if (!arg2) {
31636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31637     return 0;
31638   }
31639   {
31640     try {
31641       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31642     } catch (std::out_of_range& e) {
31643       {
31644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31645       };
31646     } catch (std::exception& e) {
31647       {
31648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31649       };
31650     } catch (Dali::DaliException e) {
31651       {
31652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31653       };
31654     } catch (...) {
31655       {
31656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31657       };
31658     }
31659   }
31660
31661   jresult = (void *)result;
31662   return jresult;
31663 }
31664
31665
31666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31667   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31668   unsigned int arg2 ;
31669
31670   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31671   arg2 = (unsigned int)jarg2;
31672   {
31673     try {
31674       (arg1)->SetTouchesRequired(arg2);
31675     } catch (std::out_of_range& e) {
31676       {
31677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31678       };
31679     } catch (std::exception& e) {
31680       {
31681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31682       };
31683     } catch (Dali::DaliException e) {
31684       {
31685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31686       };
31687     } catch (...) {
31688       {
31689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31690       };
31691     }
31692   }
31693
31694 }
31695
31696
31697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31698   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31699   unsigned int arg2 ;
31700   unsigned int arg3 ;
31701
31702   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31703   arg2 = (unsigned int)jarg2;
31704   arg3 = (unsigned int)jarg3;
31705   {
31706     try {
31707       (arg1)->SetTouchesRequired(arg2,arg3);
31708     } catch (std::out_of_range& e) {
31709       {
31710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31711       };
31712     } catch (std::exception& e) {
31713       {
31714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31715       };
31716     } catch (Dali::DaliException e) {
31717       {
31718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31719       };
31720     } catch (...) {
31721       {
31722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31723       };
31724     }
31725   }
31726
31727 }
31728
31729
31730 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31731   unsigned int jresult ;
31732   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31733   unsigned int result;
31734
31735   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31736   {
31737     try {
31738       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31739     } catch (std::out_of_range& e) {
31740       {
31741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31742       };
31743     } catch (std::exception& e) {
31744       {
31745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31746       };
31747     } catch (Dali::DaliException e) {
31748       {
31749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31750       };
31751     } catch (...) {
31752       {
31753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31754       };
31755     }
31756   }
31757
31758   jresult = result;
31759   return jresult;
31760 }
31761
31762
31763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31764   unsigned int jresult ;
31765   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31766   unsigned int result;
31767
31768   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31769   {
31770     try {
31771       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31772     } catch (std::out_of_range& e) {
31773       {
31774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31775       };
31776     } catch (std::exception& e) {
31777       {
31778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31779       };
31780     } catch (Dali::DaliException e) {
31781       {
31782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31783       };
31784     } catch (...) {
31785       {
31786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31787       };
31788     }
31789   }
31790
31791   jresult = result;
31792   return jresult;
31793 }
31794
31795
31796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31797   void * jresult ;
31798   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31799   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31800
31801   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31802   {
31803     try {
31804       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31805     } catch (std::out_of_range& e) {
31806       {
31807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31808       };
31809     } catch (std::exception& e) {
31810       {
31811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31812       };
31813     } catch (Dali::DaliException e) {
31814       {
31815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31816       };
31817     } catch (...) {
31818       {
31819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31820       };
31821     }
31822   }
31823
31824   jresult = (void *)result;
31825   return jresult;
31826 }
31827
31828
31829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31830   void * jresult ;
31831   Dali::Gesture::State arg1 ;
31832   Dali::LongPressGesture *result = 0 ;
31833
31834   arg1 = (Dali::Gesture::State)jarg1;
31835   {
31836     try {
31837       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31838     } catch (std::out_of_range& e) {
31839       {
31840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31841       };
31842     } catch (std::exception& e) {
31843       {
31844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31845       };
31846     } catch (Dali::DaliException e) {
31847       {
31848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31849       };
31850     } catch (...) {
31851       {
31852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31853       };
31854     }
31855   }
31856
31857   jresult = (void *)result;
31858   return jresult;
31859 }
31860
31861
31862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31863   void * jresult ;
31864   Dali::LongPressGesture *arg1 = 0 ;
31865   Dali::LongPressGesture *result = 0 ;
31866
31867   arg1 = (Dali::LongPressGesture *)jarg1;
31868   if (!arg1) {
31869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31870     return 0;
31871   }
31872   {
31873     try {
31874       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31875     } catch (std::out_of_range& e) {
31876       {
31877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31878       };
31879     } catch (std::exception& e) {
31880       {
31881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31882       };
31883     } catch (Dali::DaliException e) {
31884       {
31885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31886       };
31887     } catch (...) {
31888       {
31889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31890       };
31891     }
31892   }
31893
31894   jresult = (void *)result;
31895   return jresult;
31896 }
31897
31898
31899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31900   void * jresult ;
31901   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31902   Dali::LongPressGesture *arg2 = 0 ;
31903   Dali::LongPressGesture *result = 0 ;
31904
31905   arg1 = (Dali::LongPressGesture *)jarg1;
31906   arg2 = (Dali::LongPressGesture *)jarg2;
31907   if (!arg2) {
31908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31909     return 0;
31910   }
31911   {
31912     try {
31913       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31914     } catch (std::out_of_range& e) {
31915       {
31916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31917       };
31918     } catch (std::exception& e) {
31919       {
31920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31921       };
31922     } catch (Dali::DaliException e) {
31923       {
31924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31925       };
31926     } catch (...) {
31927       {
31928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31929       };
31930     }
31931   }
31932
31933   jresult = (void *)result;
31934   return jresult;
31935 }
31936
31937
31938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
31939   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31940
31941   arg1 = (Dali::LongPressGesture *)jarg1;
31942   {
31943     try {
31944       delete arg1;
31945     } catch (std::out_of_range& e) {
31946       {
31947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31948       };
31949     } catch (std::exception& e) {
31950       {
31951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31952       };
31953     } catch (Dali::DaliException e) {
31954       {
31955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31956       };
31957     } catch (...) {
31958       {
31959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31960       };
31961     }
31962   }
31963
31964 }
31965
31966
31967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
31968   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31969   unsigned int arg2 ;
31970
31971   arg1 = (Dali::LongPressGesture *)jarg1;
31972   arg2 = (unsigned int)jarg2;
31973   if (arg1) (arg1)->numberOfTouches = arg2;
31974 }
31975
31976
31977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
31978   unsigned int jresult ;
31979   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31980   unsigned int result;
31981
31982   arg1 = (Dali::LongPressGesture *)jarg1;
31983   result = (unsigned int) ((arg1)->numberOfTouches);
31984   jresult = result;
31985   return jresult;
31986 }
31987
31988
31989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
31990   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31991   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31992
31993   arg1 = (Dali::LongPressGesture *)jarg1;
31994   arg2 = (Dali::Vector2 *)jarg2;
31995   if (arg1) (arg1)->screenPoint = *arg2;
31996 }
31997
31998
31999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32000   void * jresult ;
32001   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32002   Dali::Vector2 *result = 0 ;
32003
32004   arg1 = (Dali::LongPressGesture *)jarg1;
32005   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32006   jresult = (void *)result;
32007   return jresult;
32008 }
32009
32010
32011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32012   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32013   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32014
32015   arg1 = (Dali::LongPressGesture *)jarg1;
32016   arg2 = (Dali::Vector2 *)jarg2;
32017   if (arg1) (arg1)->localPoint = *arg2;
32018 }
32019
32020
32021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32022   void * jresult ;
32023   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32024   Dali::Vector2 *result = 0 ;
32025
32026   arg1 = (Dali::LongPressGesture *)jarg1;
32027   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32028   jresult = (void *)result;
32029   return jresult;
32030 }
32031
32032
32033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32034   void * jresult ;
32035   Dali::WheelEvent *result = 0 ;
32036
32037   {
32038     try {
32039       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32040     } catch (std::out_of_range& e) {
32041       {
32042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32043       };
32044     } catch (std::exception& e) {
32045       {
32046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32047       };
32048     } catch (Dali::DaliException e) {
32049       {
32050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32051       };
32052     } catch (...) {
32053       {
32054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32055       };
32056     }
32057   }
32058
32059   jresult = (void *)result;
32060   return jresult;
32061 }
32062
32063
32064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32065   void * jresult ;
32066   Dali::WheelEvent::Type arg1 ;
32067   int arg2 ;
32068   unsigned int arg3 ;
32069   Dali::Vector2 arg4 ;
32070   int arg5 ;
32071   unsigned int arg6 ;
32072   Dali::Vector2 *argp4 ;
32073   Dali::WheelEvent *result = 0 ;
32074
32075   arg1 = (Dali::WheelEvent::Type)jarg1;
32076   arg2 = (int)jarg2;
32077   arg3 = (unsigned int)jarg3;
32078   argp4 = (Dali::Vector2 *)jarg4;
32079   if (!argp4) {
32080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32081     return 0;
32082   }
32083   arg4 = *argp4;
32084   arg5 = (int)jarg5;
32085   arg6 = (unsigned int)jarg6;
32086   {
32087     try {
32088       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32089     } catch (std::out_of_range& e) {
32090       {
32091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32092       };
32093     } catch (std::exception& e) {
32094       {
32095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32096       };
32097     } catch (Dali::DaliException e) {
32098       {
32099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32100       };
32101     } catch (...) {
32102       {
32103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32104       };
32105     }
32106   }
32107
32108   jresult = (void *)result;
32109   return jresult;
32110 }
32111
32112
32113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32114   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32115
32116   arg1 = (Dali::WheelEvent *)jarg1;
32117   {
32118     try {
32119       delete arg1;
32120     } catch (std::out_of_range& e) {
32121       {
32122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32123       };
32124     } catch (std::exception& e) {
32125       {
32126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32127       };
32128     } catch (Dali::DaliException e) {
32129       {
32130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32131       };
32132     } catch (...) {
32133       {
32134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32135       };
32136     }
32137   }
32138
32139 }
32140
32141
32142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32143   unsigned int jresult ;
32144   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32145   bool result;
32146
32147   arg1 = (Dali::WheelEvent *)jarg1;
32148   {
32149     try {
32150       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32151     } catch (std::out_of_range& e) {
32152       {
32153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32154       };
32155     } catch (std::exception& e) {
32156       {
32157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32158       };
32159     } catch (Dali::DaliException e) {
32160       {
32161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32162       };
32163     } catch (...) {
32164       {
32165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32166       };
32167     }
32168   }
32169
32170   jresult = result;
32171   return jresult;
32172 }
32173
32174
32175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32176   unsigned int jresult ;
32177   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32178   bool result;
32179
32180   arg1 = (Dali::WheelEvent *)jarg1;
32181   {
32182     try {
32183       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32184     } catch (std::out_of_range& e) {
32185       {
32186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32187       };
32188     } catch (std::exception& e) {
32189       {
32190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32191       };
32192     } catch (Dali::DaliException e) {
32193       {
32194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32195       };
32196     } catch (...) {
32197       {
32198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32199       };
32200     }
32201   }
32202
32203   jresult = result;
32204   return jresult;
32205 }
32206
32207
32208 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32209   unsigned int jresult ;
32210   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32211   bool result;
32212
32213   arg1 = (Dali::WheelEvent *)jarg1;
32214   {
32215     try {
32216       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32217     } catch (std::out_of_range& e) {
32218       {
32219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32220       };
32221     } catch (std::exception& e) {
32222       {
32223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32224       };
32225     } catch (Dali::DaliException e) {
32226       {
32227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32228       };
32229     } catch (...) {
32230       {
32231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32232       };
32233     }
32234   }
32235
32236   jresult = result;
32237   return jresult;
32238 }
32239
32240
32241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32242   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32243   Dali::WheelEvent::Type arg2 ;
32244
32245   arg1 = (Dali::WheelEvent *)jarg1;
32246   arg2 = (Dali::WheelEvent::Type)jarg2;
32247   if (arg1) (arg1)->type = arg2;
32248 }
32249
32250
32251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32252   int jresult ;
32253   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32254   Dali::WheelEvent::Type result;
32255
32256   arg1 = (Dali::WheelEvent *)jarg1;
32257   result = (Dali::WheelEvent::Type) ((arg1)->type);
32258   jresult = (int)result;
32259   return jresult;
32260 }
32261
32262
32263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32264   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32265   int arg2 ;
32266
32267   arg1 = (Dali::WheelEvent *)jarg1;
32268   arg2 = (int)jarg2;
32269   if (arg1) (arg1)->direction = arg2;
32270 }
32271
32272
32273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32274   int jresult ;
32275   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32276   int result;
32277
32278   arg1 = (Dali::WheelEvent *)jarg1;
32279   result = (int) ((arg1)->direction);
32280   jresult = result;
32281   return jresult;
32282 }
32283
32284
32285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32286   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32287   unsigned int arg2 ;
32288
32289   arg1 = (Dali::WheelEvent *)jarg1;
32290   arg2 = (unsigned int)jarg2;
32291   if (arg1) (arg1)->modifiers = arg2;
32292 }
32293
32294
32295 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32296   unsigned int jresult ;
32297   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32298   unsigned int result;
32299
32300   arg1 = (Dali::WheelEvent *)jarg1;
32301   result = (unsigned int) ((arg1)->modifiers);
32302   jresult = result;
32303   return jresult;
32304 }
32305
32306
32307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32308   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32309   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32310
32311   arg1 = (Dali::WheelEvent *)jarg1;
32312   arg2 = (Dali::Vector2 *)jarg2;
32313   if (arg1) (arg1)->point = *arg2;
32314 }
32315
32316
32317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32318   void * jresult ;
32319   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32320   Dali::Vector2 *result = 0 ;
32321
32322   arg1 = (Dali::WheelEvent *)jarg1;
32323   result = (Dali::Vector2 *)& ((arg1)->point);
32324   jresult = (void *)result;
32325   return jresult;
32326 }
32327
32328
32329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32330   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32331   int arg2 ;
32332
32333   arg1 = (Dali::WheelEvent *)jarg1;
32334   arg2 = (int)jarg2;
32335   if (arg1) (arg1)->z = arg2;
32336 }
32337
32338
32339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32340   int jresult ;
32341   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32342   int result;
32343
32344   arg1 = (Dali::WheelEvent *)jarg1;
32345   result = (int) ((arg1)->z);
32346   jresult = result;
32347   return jresult;
32348 }
32349
32350
32351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32352   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32353   unsigned int arg2 ;
32354
32355   arg1 = (Dali::WheelEvent *)jarg1;
32356   arg2 = (unsigned int)jarg2;
32357   if (arg1) (arg1)->timeStamp = arg2;
32358 }
32359
32360
32361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32362   unsigned int jresult ;
32363   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32364   unsigned int result;
32365
32366   arg1 = (Dali::WheelEvent *)jarg1;
32367   result = (unsigned int) ((arg1)->timeStamp);
32368   jresult = result;
32369   return jresult;
32370 }
32371
32372 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32373   char * jresult ;
32374   Dali::KeyEvent *arg1 = 0 ;
32375   std::string result;
32376
32377   arg1 = (Dali::KeyEvent *)jarg1;
32378   if (!arg1) {
32379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32380     return 0;
32381   }
32382   {
32383     try {
32384       result = arg1->GetDeviceName();
32385     } catch (std::out_of_range& e) {
32386       {
32387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32388       };
32389     } catch (std::exception& e) {
32390       {
32391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32392       };
32393     } catch (Dali::DaliException e) {
32394       {
32395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32396       };
32397     } catch (...) {
32398       {
32399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32400       };
32401     }
32402   }
32403
32404   jresult = SWIG_csharp_string_callback((&result)->c_str());
32405   return jresult;
32406 }
32407
32408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32409   int jresult ;
32410   Dali::KeyEvent *arg1 = 0 ;
32411   Dali::Device::Class::Type result;
32412
32413   arg1 = (Dali::KeyEvent *)jarg1;
32414   if (!arg1) {
32415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32416     return 0;
32417   }
32418   {
32419     try {
32420       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32421     } catch (std::out_of_range& e) {
32422       {
32423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32424       };
32425     } catch (std::exception& e) {
32426       {
32427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32428       };
32429     } catch (Dali::DaliException e) {
32430       {
32431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32432       };
32433     } catch (...) {
32434       {
32435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32436       };
32437     }
32438   }
32439
32440   jresult = (int)result;
32441   return jresult;
32442 }
32443
32444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32445   int jresult ;
32446   Dali::KeyEvent *arg1 = 0 ;
32447   Dali::Device::Subclass::Type result;
32448
32449   arg1 = (Dali::KeyEvent *)jarg1;
32450   if (!arg1) {
32451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32452     return 0;
32453   }
32454   {
32455     try {
32456       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32457     } catch (std::out_of_range& e) {
32458       {
32459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32460       };
32461     } catch (std::exception& e) {
32462       {
32463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32464       };
32465     } catch (Dali::DaliException e) {
32466       {
32467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32468       };
32469     } catch (...) {
32470       {
32471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32472       };
32473     }
32474   }
32475
32476   jresult = (int)result;
32477   return jresult;
32478 }
32479
32480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32481   Dali::Actor arg1 ;
32482   Dali::Actor *argp1 ;
32483
32484   argp1 = (Dali::Actor *)jarg1;
32485   if (!argp1) {
32486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32487     return ;
32488   }
32489   arg1 = *argp1;
32490   {
32491     try {
32492       arg1.Raise();
32493     } catch (std::out_of_range& e) {
32494       {
32495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32496       };
32497     } catch (std::exception& e) {
32498       {
32499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32500       };
32501     } catch (Dali::DaliException e) {
32502       {
32503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32504       };
32505     } catch (...) {
32506       {
32507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32508       };
32509     }
32510   }
32511
32512 }
32513
32514
32515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32516   Dali::Actor arg1 ;
32517   Dali::Actor *argp1 ;
32518
32519   argp1 = (Dali::Actor *)jarg1;
32520   if (!argp1) {
32521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32522     return ;
32523   }
32524   arg1 = *argp1;
32525   {
32526     try {
32527       arg1.Lower();
32528     } catch (std::out_of_range& e) {
32529       {
32530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32531       };
32532     } catch (std::exception& e) {
32533       {
32534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32535       };
32536     } catch (Dali::DaliException e) {
32537       {
32538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32539       };
32540     } catch (...) {
32541       {
32542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32543       };
32544     }
32545   }
32546
32547 }
32548
32549
32550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32551   Dali::Actor arg1 ;
32552   Dali::Actor *argp1 ;
32553
32554   argp1 = (Dali::Actor *)jarg1;
32555   if (!argp1) {
32556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32557     return ;
32558   }
32559   arg1 = *argp1;
32560   {
32561     try {
32562       arg1.RaiseToTop();
32563     } catch (std::out_of_range& e) {
32564       {
32565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32566       };
32567     } catch (std::exception& e) {
32568       {
32569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32570       };
32571     } catch (Dali::DaliException e) {
32572       {
32573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32574       };
32575     } catch (...) {
32576       {
32577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32578       };
32579     }
32580   }
32581
32582 }
32583
32584
32585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32586   Dali::Actor arg1 ;
32587   Dali::Actor *argp1 ;
32588
32589   argp1 = (Dali::Actor *)jarg1;
32590   if (!argp1) {
32591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32592     return ;
32593   }
32594   arg1 = *argp1;
32595   {
32596     try {
32597       arg1.LowerToBottom();
32598     } catch (std::out_of_range& e) {
32599       {
32600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32601       };
32602     } catch (std::exception& e) {
32603       {
32604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32605       };
32606     } catch (Dali::DaliException e) {
32607       {
32608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32609       };
32610     } catch (...) {
32611       {
32612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32613       };
32614     }
32615   }
32616
32617 }
32618
32619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32620   Dali::Actor arg1 ;
32621   Dali::Actor arg2 ;
32622   Dali::Actor *argp1 ;
32623   Dali::Actor *argp2 ;
32624
32625   argp1 = (Dali::Actor *)jarg1;
32626   if (!argp1) {
32627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32628     return ;
32629   }
32630   arg1 = *argp1;
32631   argp2 = (Dali::Actor *)jarg2;
32632   if (!argp2) {
32633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32634     return ;
32635   }
32636   arg2 = *argp2;
32637   {
32638     try {
32639       arg1.RaiseAbove(arg2);
32640     } catch (std::out_of_range& e) {
32641       {
32642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32643       };
32644     } catch (std::exception& e) {
32645       {
32646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32647       };
32648     } catch (Dali::DaliException e) {
32649       {
32650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32651       };
32652     } catch (...) {
32653       {
32654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32655       };
32656     }
32657   }
32658
32659 }
32660
32661
32662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32663   Dali::Actor arg1 ;
32664   Dali::Actor arg2 ;
32665   Dali::Actor *argp1 ;
32666   Dali::Actor *argp2 ;
32667
32668   argp1 = (Dali::Actor *)jarg1;
32669   if (!argp1) {
32670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32671     return ;
32672   }
32673   arg1 = *argp1;
32674   argp2 = (Dali::Actor *)jarg2;
32675   if (!argp2) {
32676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32677     return ;
32678   }
32679   arg2 = *argp2;
32680   {
32681     try {
32682       arg1.LowerBelow(arg2);
32683     } catch (std::out_of_range& e) {
32684       {
32685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32686       };
32687     } catch (std::exception& e) {
32688       {
32689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32690       };
32691     } catch (Dali::DaliException e) {
32692       {
32693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32694       };
32695     } catch (...) {
32696       {
32697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32698       };
32699     }
32700   }
32701
32702 }
32703
32704
32705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32706   void * jresult ;
32707   Dali::Actor arg1 ;
32708   Dali::Actor *argp1 ;
32709   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32710
32711   argp1 = (Dali::Actor *)jarg1;
32712   if (!argp1) {
32713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32714     return 0;
32715   }
32716   arg1 = *argp1;
32717   {
32718     try {
32719       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32720     } catch (std::out_of_range& e) {
32721       {
32722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32723       };
32724     } catch (std::exception& e) {
32725       {
32726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32727       };
32728     } catch (Dali::DaliException e) {
32729       {
32730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32731       };
32732     } catch (...) {
32733       {
32734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32735       };
32736     }
32737   }
32738
32739   jresult = (void *)result;
32740   return jresult;
32741 }
32742
32743
32744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32745   void * jresult ;
32746   Dali::Actor *arg1 ;
32747   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32748
32749   arg1 = (Dali::Actor *)jarg1;
32750   {
32751     try {
32752       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32753     } catch (std::out_of_range& e) {
32754       {
32755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32756       };
32757     } catch (std::exception& e) {
32758       {
32759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32760       };
32761     } catch (Dali::DaliException e) {
32762       {
32763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32764       };
32765     } catch (...) {
32766       {
32767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32768       };
32769     }
32770   }
32771
32772   jresult = (void *)result;
32773   return jresult;
32774 }
32775
32776
32777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32778   int jresult ;
32779   int result;
32780
32781   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32782   jresult = (int)result;
32783   return jresult;
32784 }
32785
32786
32787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32788   int jresult ;
32789   int result;
32790
32791   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32792   jresult = (int)result;
32793   return jresult;
32794 }
32795
32796
32797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32798   int jresult ;
32799   int result;
32800
32801   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32802   jresult = (int)result;
32803   return jresult;
32804 }
32805
32806
32807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32808   int jresult ;
32809   int result;
32810
32811   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32812   jresult = (int)result;
32813   return jresult;
32814 }
32815
32816
32817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32818   int jresult ;
32819   int result;
32820
32821   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32822   jresult = (int)result;
32823   return jresult;
32824 }
32825
32826
32827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32828   int jresult ;
32829   int result;
32830
32831   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32832   jresult = (int)result;
32833   return jresult;
32834 }
32835
32836
32837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32838   int jresult ;
32839   int result;
32840
32841   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32842   jresult = (int)result;
32843   return jresult;
32844 }
32845
32846
32847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32848   int jresult ;
32849   int result;
32850
32851   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32852   jresult = (int)result;
32853   return jresult;
32854 }
32855
32856
32857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32858   int jresult ;
32859   int result;
32860
32861   result = (int)Dali::Actor::Property::SIZE;
32862   jresult = (int)result;
32863   return jresult;
32864 }
32865
32866
32867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32868   int jresult ;
32869   int result;
32870
32871   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32872   jresult = (int)result;
32873   return jresult;
32874 }
32875
32876
32877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32878   int jresult ;
32879   int result;
32880
32881   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32882   jresult = (int)result;
32883   return jresult;
32884 }
32885
32886
32887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32888   int jresult ;
32889   int result;
32890
32891   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32892   jresult = (int)result;
32893   return jresult;
32894 }
32895
32896
32897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32898   int jresult ;
32899   int result;
32900
32901   result = (int)Dali::Actor::Property::POSITION;
32902   jresult = (int)result;
32903   return jresult;
32904 }
32905
32906
32907 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32908   int jresult ;
32909   int result;
32910
32911   result = (int)Dali::Actor::Property::POSITION_X;
32912   jresult = (int)result;
32913   return jresult;
32914 }
32915
32916
32917 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32918   int jresult ;
32919   int result;
32920
32921   result = (int)Dali::Actor::Property::POSITION_Y;
32922   jresult = (int)result;
32923   return jresult;
32924 }
32925
32926
32927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32928   int jresult ;
32929   int result;
32930
32931   result = (int)Dali::Actor::Property::POSITION_Z;
32932   jresult = (int)result;
32933   return jresult;
32934 }
32935
32936
32937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
32938   int jresult ;
32939   int result;
32940
32941   result = (int)Dali::Actor::Property::WORLD_POSITION;
32942   jresult = (int)result;
32943   return jresult;
32944 }
32945
32946
32947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
32948   int jresult ;
32949   int result;
32950
32951   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
32952   jresult = (int)result;
32953   return jresult;
32954 }
32955
32956
32957 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
32958   int jresult ;
32959   int result;
32960
32961   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
32962   jresult = (int)result;
32963   return jresult;
32964 }
32965
32966
32967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
32968   int jresult ;
32969   int result;
32970
32971   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
32972   jresult = (int)result;
32973   return jresult;
32974 }
32975
32976
32977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
32978   int jresult ;
32979   int result;
32980
32981   result = (int)Dali::Actor::Property::ORIENTATION;
32982   jresult = (int)result;
32983   return jresult;
32984 }
32985
32986
32987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
32988   int jresult ;
32989   int result;
32990
32991   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
32992   jresult = (int)result;
32993   return jresult;
32994 }
32995
32996
32997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
32998   int jresult ;
32999   int result;
33000
33001   result = (int)Dali::Actor::Property::SCALE;
33002   jresult = (int)result;
33003   return jresult;
33004 }
33005
33006
33007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33008   int jresult ;
33009   int result;
33010
33011   result = (int)Dali::Actor::Property::SCALE_X;
33012   jresult = (int)result;
33013   return jresult;
33014 }
33015
33016
33017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33018   int jresult ;
33019   int result;
33020
33021   result = (int)Dali::Actor::Property::SCALE_Y;
33022   jresult = (int)result;
33023   return jresult;
33024 }
33025
33026
33027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33028   int jresult ;
33029   int result;
33030
33031   result = (int)Dali::Actor::Property::SCALE_Z;
33032   jresult = (int)result;
33033   return jresult;
33034 }
33035
33036
33037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33038   int jresult ;
33039   int result;
33040
33041   result = (int)Dali::Actor::Property::WORLD_SCALE;
33042   jresult = (int)result;
33043   return jresult;
33044 }
33045
33046
33047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33048   int jresult ;
33049   int result;
33050
33051   result = (int)Dali::Actor::Property::VISIBLE;
33052   jresult = (int)result;
33053   return jresult;
33054 }
33055
33056
33057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33058   int jresult ;
33059   int result;
33060
33061   result = (int)Dali::Actor::Property::COLOR;
33062   jresult = (int)result;
33063   return jresult;
33064 }
33065
33066
33067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33068   int jresult ;
33069   int result;
33070
33071   result = (int)Dali::Actor::Property::COLOR_RED;
33072   jresult = (int)result;
33073   return jresult;
33074 }
33075
33076
33077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33078   int jresult ;
33079   int result;
33080
33081   result = (int)Dali::Actor::Property::COLOR_GREEN;
33082   jresult = (int)result;
33083   return jresult;
33084 }
33085
33086
33087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33088   int jresult ;
33089   int result;
33090
33091   result = (int)Dali::Actor::Property::COLOR_BLUE;
33092   jresult = (int)result;
33093   return jresult;
33094 }
33095
33096
33097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33098   int jresult ;
33099   int result;
33100
33101   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33102   jresult = (int)result;
33103   return jresult;
33104 }
33105
33106
33107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33108   int jresult ;
33109   int result;
33110
33111   result = (int)Dali::Actor::Property::WORLD_COLOR;
33112   jresult = (int)result;
33113   return jresult;
33114 }
33115
33116
33117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33118   int jresult ;
33119   int result;
33120
33121   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33122   jresult = (int)result;
33123   return jresult;
33124 }
33125
33126
33127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33128   int jresult ;
33129   int result;
33130
33131   result = (int)Dali::Actor::Property::NAME;
33132   jresult = (int)result;
33133   return jresult;
33134 }
33135
33136
33137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33138   int jresult ;
33139   int result;
33140
33141   result = (int)Dali::Actor::Property::SENSITIVE;
33142   jresult = (int)result;
33143   return jresult;
33144 }
33145
33146
33147 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33148   int jresult ;
33149   int result;
33150
33151   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33152   jresult = (int)result;
33153   return jresult;
33154 }
33155
33156
33157 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33158   int jresult ;
33159   int result;
33160
33161   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33162   jresult = (int)result;
33163   return jresult;
33164 }
33165
33166
33167 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33168   int jresult ;
33169   int result;
33170
33171   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33172   jresult = (int)result;
33173   return jresult;
33174 }
33175
33176
33177 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33178   int jresult ;
33179   int result;
33180
33181   result = (int)Dali::Actor::Property::COLOR_MODE;
33182   jresult = (int)result;
33183   return jresult;
33184 }
33185
33186
33187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33188   int jresult ;
33189   int result;
33190
33191   result = (int)Dali::Actor::Property::DRAW_MODE;
33192   jresult = (int)result;
33193   return jresult;
33194 }
33195
33196
33197 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33198   int jresult ;
33199   int result;
33200
33201   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33202   jresult = (int)result;
33203   return jresult;
33204 }
33205
33206
33207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33208   int jresult ;
33209   int result;
33210
33211   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33212   jresult = (int)result;
33213   return jresult;
33214 }
33215
33216
33217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33218   int jresult ;
33219   int result;
33220
33221   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33222   jresult = (int)result;
33223   return jresult;
33224 }
33225
33226
33227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33228   int jresult ;
33229   int result;
33230
33231   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33232   jresult = (int)result;
33233   return jresult;
33234 }
33235
33236
33237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33238   int jresult ;
33239   int result;
33240
33241   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33242   jresult = (int)result;
33243   return jresult;
33244 }
33245
33246
33247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33248   int jresult ;
33249   int result;
33250
33251   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33252   jresult = (int)result;
33253   return jresult;
33254 }
33255
33256
33257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33258   int jresult ;
33259   int result;
33260
33261   result = (int)Dali::Actor::Property::PADDING;
33262   jresult = (int)result;
33263   return jresult;
33264 }
33265
33266
33267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33268   int jresult ;
33269   int result;
33270
33271   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33272   jresult = (int)result;
33273   return jresult;
33274 }
33275
33276
33277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33278   int jresult ;
33279   int result;
33280
33281   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33282   jresult = (int)result;
33283   return jresult;
33284 }
33285
33286
33287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33288   int jresult ;
33289   int result;
33290
33291   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33292   jresult = (int)result;
33293   return jresult;
33294 }
33295
33296
33297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33298   int jresult ;
33299   int result;
33300
33301   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33302   jresult = (int)result;
33303   return jresult;
33304 }
33305
33306 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
33307
33308   return Dali::Actor::Property::OPACITY;
33309 }
33310
33311 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
33312
33313   return Dali::Actor::Property::SCREEN_POSITION;
33314 }
33315
33316 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
33317
33318   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
33319 }
33320
33321 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
33322   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
33323 }
33324
33325 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
33326   return Dali::Actor::Property::LAYOUT_DIRECTION;
33327 }
33328
33329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33330   void * jresult ;
33331   Dali::Actor::Property *result = 0 ;
33332
33333   {
33334     try {
33335       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33336     } catch (std::out_of_range& e) {
33337       {
33338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33339       };
33340     } catch (std::exception& e) {
33341       {
33342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33343       };
33344     } catch (Dali::DaliException e) {
33345       {
33346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33347       };
33348     } catch (...) {
33349       {
33350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33351       };
33352     }
33353   }
33354
33355   jresult = (void *)result;
33356   return jresult;
33357 }
33358
33359
33360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33361   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33362
33363   arg1 = (Dali::Actor::Property *)jarg1;
33364   {
33365     try {
33366       delete arg1;
33367     } catch (std::out_of_range& e) {
33368       {
33369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33370       };
33371     } catch (std::exception& e) {
33372       {
33373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33374       };
33375     } catch (Dali::DaliException e) {
33376       {
33377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33378       };
33379     } catch (...) {
33380       {
33381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33382       };
33383     }
33384   }
33385
33386 }
33387
33388
33389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33390   void * jresult ;
33391   Dali::Actor *result = 0 ;
33392
33393   {
33394     try {
33395       result = (Dali::Actor *)new Dali::Actor();
33396     } catch (std::out_of_range& e) {
33397       {
33398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33399       };
33400     } catch (std::exception& e) {
33401       {
33402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33403       };
33404     } catch (Dali::DaliException e) {
33405       {
33406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33407       };
33408     } catch (...) {
33409       {
33410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33411       };
33412     }
33413   }
33414
33415   jresult = (void *)result;
33416   return jresult;
33417 }
33418
33419
33420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33421   void * jresult ;
33422   Dali::Actor result;
33423
33424   {
33425     try {
33426       result = Dali::Actor::New();
33427     } catch (std::out_of_range& e) {
33428       {
33429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33430       };
33431     } catch (std::exception& e) {
33432       {
33433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33434       };
33435     } catch (Dali::DaliException e) {
33436       {
33437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33438       };
33439     } catch (...) {
33440       {
33441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33442       };
33443     }
33444   }
33445
33446   jresult = new Dali::Actor((const Dali::Actor &)result);
33447   return jresult;
33448 }
33449
33450
33451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33452   void * jresult ;
33453   Dali::BaseHandle arg1 ;
33454   Dali::BaseHandle *argp1 ;
33455   Dali::Actor result;
33456
33457   argp1 = (Dali::BaseHandle *)jarg1;
33458   if (!argp1) {
33459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33460     return 0;
33461   }
33462   arg1 = *argp1;
33463   {
33464     try {
33465       result = Dali::Actor::DownCast(arg1);
33466     } catch (std::out_of_range& e) {
33467       {
33468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33469       };
33470     } catch (std::exception& e) {
33471       {
33472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33473       };
33474     } catch (Dali::DaliException e) {
33475       {
33476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33477       };
33478     } catch (...) {
33479       {
33480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33481       };
33482     }
33483   }
33484
33485   jresult = new Dali::Actor((const Dali::Actor &)result);
33486   return jresult;
33487 }
33488
33489
33490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33491   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33492
33493   arg1 = (Dali::Actor *)jarg1;
33494   {
33495     try {
33496       delete arg1;
33497     } catch (std::out_of_range& e) {
33498       {
33499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33500       };
33501     } catch (std::exception& e) {
33502       {
33503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33504       };
33505     } catch (Dali::DaliException e) {
33506       {
33507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33508       };
33509     } catch (...) {
33510       {
33511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33512       };
33513     }
33514   }
33515
33516 }
33517
33518
33519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33520   void * jresult ;
33521   Dali::Actor *arg1 = 0 ;
33522   Dali::Actor *result = 0 ;
33523
33524   arg1 = (Dali::Actor *)jarg1;
33525   if (!arg1) {
33526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33527     return 0;
33528   }
33529   {
33530     try {
33531       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33532     } catch (std::out_of_range& e) {
33533       {
33534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33535       };
33536     } catch (std::exception& e) {
33537       {
33538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33539       };
33540     } catch (Dali::DaliException e) {
33541       {
33542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33543       };
33544     } catch (...) {
33545       {
33546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33547       };
33548     }
33549   }
33550
33551   jresult = (void *)result;
33552   return jresult;
33553 }
33554
33555
33556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33557   void * jresult ;
33558   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33559   Dali::Actor *arg2 = 0 ;
33560   Dali::Actor *result = 0 ;
33561
33562   arg1 = (Dali::Actor *)jarg1;
33563   arg2 = (Dali::Actor *)jarg2;
33564   if (!arg2) {
33565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33566     return 0;
33567   }
33568   {
33569     try {
33570       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33571     } catch (std::out_of_range& e) {
33572       {
33573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33574       };
33575     } catch (std::exception& e) {
33576       {
33577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33578       };
33579     } catch (Dali::DaliException e) {
33580       {
33581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33582       };
33583     } catch (...) {
33584       {
33585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33586       };
33587     }
33588   }
33589
33590   jresult = (void *)result;
33591   return jresult;
33592 }
33593
33594
33595 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33596   char * jresult ;
33597   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33598   std::string *result = 0 ;
33599   std::string name = "";
33600
33601   arg1 = (Dali::Actor *)jarg1;
33602   {
33603     try {
33604       name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
33605       result = (std::string *) &name;
33606       jresult = SWIG_csharp_string_callback(result->c_str());
33607     } catch (std::out_of_range& e) {
33608       {
33609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33610       };
33611     } catch (std::exception& e) {
33612       {
33613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33614       };
33615     } catch (Dali::DaliException e) {
33616       {
33617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33618       };
33619     } catch (...) {
33620       {
33621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33622       };
33623     }
33624   }
33625   return jresult;
33626 }
33627
33628
33629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33630   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33631   std::string *arg2 = 0 ;
33632
33633   arg1 = (Dali::Actor *)jarg1;
33634   if (!jarg2) {
33635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33636     return ;
33637   }
33638   std::string arg2_str(jarg2);
33639   arg2 = &arg2_str;
33640   {
33641     try {
33642       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
33643     } catch (std::out_of_range& e) {
33644       {
33645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33646       };
33647     } catch (std::exception& e) {
33648       {
33649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33650       };
33651     } catch (Dali::DaliException e) {
33652       {
33653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33654       };
33655     } catch (...) {
33656       {
33657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33658       };
33659     }
33660   }
33661
33662
33663   //argout typemap for const std::string&
33664
33665 }
33666
33667
33668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33669   unsigned int jresult ;
33670   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33671   unsigned int result;
33672
33673   arg1 = (Dali::Actor *)jarg1;
33674
33675   if(!arg1) {
33676     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33677     return -1;
33678   }
33679
33680   {
33681     try {
33682       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
33683     } catch (std::out_of_range& e) {
33684       {
33685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33686       };
33687     } catch (std::exception& e) {
33688       {
33689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33690       };
33691     } catch (Dali::DaliException e) {
33692       {
33693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33694       };
33695     } catch (...) {
33696       {
33697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33698       };
33699     }
33700   }
33701
33702   jresult = result;
33703   return jresult;
33704 }
33705
33706
33707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33708   unsigned int jresult ;
33709   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33710   bool result;
33711
33712   arg1 = (Dali::Actor *)jarg1;
33713   {
33714     try {
33715       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
33716     } catch (std::out_of_range& e) {
33717       {
33718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33719       };
33720     } catch (std::exception& e) {
33721       {
33722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33723       };
33724     } catch (Dali::DaliException e) {
33725       {
33726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33727       };
33728     } catch (...) {
33729       {
33730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33731       };
33732     }
33733   }
33734
33735   jresult = result;
33736   return jresult;
33737 }
33738
33739
33740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33741   unsigned int jresult ;
33742   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33743   bool result;
33744
33745   arg1 = (Dali::Actor *)jarg1;
33746   {
33747     try {
33748       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
33749     } catch (std::out_of_range& e) {
33750       {
33751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33752       };
33753     } catch (std::exception& e) {
33754       {
33755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33756       };
33757     } catch (Dali::DaliException e) {
33758       {
33759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33760       };
33761     } catch (...) {
33762       {
33763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33764       };
33765     }
33766   }
33767
33768   jresult = result;
33769   return jresult;
33770 }
33771
33772
33773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33774   unsigned int jresult ;
33775   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33776   bool result;
33777
33778   arg1 = (Dali::Actor *)jarg1;
33779   {
33780     try {
33781       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
33782     } catch (std::out_of_range& e) {
33783       {
33784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33785       };
33786     } catch (std::exception& e) {
33787       {
33788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33789       };
33790     } catch (Dali::DaliException e) {
33791       {
33792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33793       };
33794     } catch (...) {
33795       {
33796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33797       };
33798     }
33799   }
33800
33801   jresult = result;
33802   return jresult;
33803 }
33804
33805
33806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33807   void * jresult ;
33808   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33809   Dali::Layer result;
33810
33811   arg1 = (Dali::Actor *)jarg1;
33812   {
33813     try {
33814       result = (arg1)->GetLayer();
33815     } catch (std::out_of_range& e) {
33816       {
33817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33818       };
33819     } catch (std::exception& e) {
33820       {
33821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33822       };
33823     } catch (Dali::DaliException e) {
33824       {
33825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33826       };
33827     } catch (...) {
33828       {
33829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33830       };
33831     }
33832   }
33833
33834   jresult = new Dali::Layer((const Dali::Layer &)result);
33835   return jresult;
33836 }
33837
33838
33839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33840   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33841   Dali::Actor arg2 ;
33842   Dali::Actor *argp2 ;
33843
33844   arg1 = (Dali::Actor *)jarg1;
33845   argp2 = (Dali::Actor *)jarg2;
33846   if (!argp2) {
33847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33848     return ;
33849   }
33850   arg2 = *argp2;
33851   {
33852     try {
33853       (arg1)->Add(arg2);
33854     } catch (std::out_of_range& e) {
33855       {
33856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33857       };
33858     } catch (std::exception& e) {
33859       {
33860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33861       };
33862     } catch (Dali::DaliException e) {
33863       {
33864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33865       };
33866     } catch (...) {
33867       {
33868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33869       };
33870     }
33871   }
33872
33873 }
33874
33875
33876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33877   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33878   Dali::Actor arg2 ;
33879   Dali::Actor *argp2 ;
33880
33881   arg1 = (Dali::Actor *)jarg1;
33882   argp2 = (Dali::Actor *)jarg2;
33883   if (!argp2) {
33884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33885     return ;
33886   }
33887   arg2 = *argp2;
33888   {
33889     try {
33890       (arg1)->Remove(arg2);
33891     } catch (std::out_of_range& e) {
33892       {
33893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33894       };
33895     } catch (std::exception& e) {
33896       {
33897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33898       };
33899     } catch (Dali::DaliException e) {
33900       {
33901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33902       };
33903     } catch (...) {
33904       {
33905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33906       };
33907     }
33908   }
33909
33910 }
33911
33912
33913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33914   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33915
33916   arg1 = (Dali::Actor *)jarg1;
33917   {
33918     try {
33919       (arg1)->Unparent();
33920     } catch (std::out_of_range& e) {
33921       {
33922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33923       };
33924     } catch (std::exception& e) {
33925       {
33926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33927       };
33928     } catch (Dali::DaliException e) {
33929       {
33930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33931       };
33932     } catch (...) {
33933       {
33934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33935       };
33936     }
33937   }
33938
33939 }
33940
33941
33942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33943   unsigned int jresult ;
33944   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33945   unsigned int result;
33946
33947   arg1 = (Dali::Actor *)jarg1;
33948   {
33949     try {
33950       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33951     } catch (std::out_of_range& e) {
33952       {
33953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33954       };
33955     } catch (std::exception& e) {
33956       {
33957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33958       };
33959     } catch (Dali::DaliException e) {
33960       {
33961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33962       };
33963     } catch (...) {
33964       {
33965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33966       };
33967     }
33968   }
33969
33970   jresult = result;
33971   return jresult;
33972 }
33973
33974
33975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
33976   void * jresult ;
33977   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33978   unsigned int arg2 ;
33979   Dali::Actor result;
33980
33981   arg1 = (Dali::Actor *)jarg1;
33982   arg2 = (unsigned int)jarg2;
33983   {
33984     try {
33985       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
33986     } catch (std::out_of_range& e) {
33987       {
33988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33989       };
33990     } catch (std::exception& e) {
33991       {
33992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33993       };
33994     } catch (Dali::DaliException e) {
33995       {
33996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33997       };
33998     } catch (...) {
33999       {
34000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34001       };
34002     }
34003   }
34004
34005   jresult = new Dali::Actor((const Dali::Actor &)result);
34006   return jresult;
34007 }
34008
34009
34010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34011   void * jresult ;
34012   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34013   std::string *arg2 = 0 ;
34014   Dali::Actor result;
34015
34016   arg1 = (Dali::Actor *)jarg1;
34017   if (!jarg2) {
34018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34019     return 0;
34020   }
34021   std::string arg2_str(jarg2);
34022   arg2 = &arg2_str;
34023   {
34024     try {
34025       result = (arg1)->FindChildByName((std::string const &)*arg2);
34026     } catch (std::out_of_range& e) {
34027       {
34028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34029       };
34030     } catch (std::exception& e) {
34031       {
34032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34033       };
34034     } catch (Dali::DaliException e) {
34035       {
34036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34037       };
34038     } catch (...) {
34039       {
34040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34041       };
34042     }
34043   }
34044
34045   jresult = new Dali::Actor((const Dali::Actor &)result);
34046
34047   //argout typemap for const std::string&
34048
34049   return jresult;
34050 }
34051
34052
34053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34054   void * jresult ;
34055   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34056   unsigned int arg2 ;
34057   Dali::Actor result;
34058
34059   arg1 = (Dali::Actor *)jarg1;
34060   arg2 = (unsigned int)jarg2;
34061   {
34062     try {
34063       result = (arg1)->FindChildById(arg2);
34064     } catch (std::out_of_range& e) {
34065       {
34066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34067       };
34068     } catch (std::exception& e) {
34069       {
34070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34071       };
34072     } catch (Dali::DaliException e) {
34073       {
34074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34075       };
34076     } catch (...) {
34077       {
34078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34079       };
34080     }
34081   }
34082
34083   jresult = new Dali::Actor((const Dali::Actor &)result);
34084   return jresult;
34085 }
34086
34087
34088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34089   void * jresult ;
34090   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34091   Dali::Actor result;
34092
34093   arg1 = (Dali::Actor *)jarg1;
34094   {
34095     try {
34096       result = ((Dali::Actor const *)arg1)->GetParent();
34097     } catch (std::out_of_range& e) {
34098       {
34099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34100       };
34101     } catch (std::exception& e) {
34102       {
34103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34104       };
34105     } catch (Dali::DaliException e) {
34106       {
34107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34108       };
34109     } catch (...) {
34110       {
34111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34112       };
34113     }
34114   }
34115
34116   jresult = new Dali::Actor((const Dali::Actor &)result);
34117   return jresult;
34118 }
34119
34120
34121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34122   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34123   Dali::Vector3 *arg2 = 0 ;
34124
34125   arg1 = (Dali::Actor *)jarg1;
34126   arg2 = (Dali::Vector3 *)jarg2;
34127   if (!arg2) {
34128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34129     return ;
34130   }
34131   {
34132     try {
34133       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
34134     } catch (std::out_of_range& e) {
34135       {
34136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34137       };
34138     } catch (std::exception& e) {
34139       {
34140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34141       };
34142     } catch (Dali::DaliException e) {
34143       {
34144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34145       };
34146     } catch (...) {
34147       {
34148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34149       };
34150     }
34151   }
34152
34153 }
34154
34155
34156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34157   void * jresult ;
34158   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34159   Dali::Vector3 result;
34160
34161   arg1 = (Dali::Actor *)jarg1;
34162   {
34163     try {
34164       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
34165     } catch (std::out_of_range& e) {
34166       {
34167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34168       };
34169     } catch (std::exception& e) {
34170       {
34171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34172       };
34173     } catch (Dali::DaliException e) {
34174       {
34175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34176       };
34177     } catch (...) {
34178       {
34179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34180       };
34181     }
34182   }
34183
34184   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34185   return jresult;
34186 }
34187
34188
34189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34190   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34191   Dali::Vector3 *arg2 = 0 ;
34192
34193   arg1 = (Dali::Actor *)jarg1;
34194   arg2 = (Dali::Vector3 *)jarg2;
34195   if (!arg2) {
34196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34197     return ;
34198   }
34199   {
34200     try {
34201       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
34202     } catch (std::out_of_range& e) {
34203       {
34204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34205       };
34206     } catch (std::exception& e) {
34207       {
34208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34209       };
34210     } catch (Dali::DaliException e) {
34211       {
34212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34213       };
34214     } catch (...) {
34215       {
34216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34217       };
34218     }
34219   }
34220
34221 }
34222
34223
34224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34225   void * jresult ;
34226   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34227   Dali::Vector3 result;
34228
34229   arg1 = (Dali::Actor *)jarg1;
34230   {
34231     try {
34232       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
34233     } catch (std::out_of_range& e) {
34234       {
34235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34236       };
34237     } catch (std::exception& e) {
34238       {
34239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34240       };
34241     } catch (Dali::DaliException e) {
34242       {
34243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34244       };
34245     } catch (...) {
34246       {
34247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34248       };
34249     }
34250   }
34251
34252   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34253   return jresult;
34254 }
34255
34256
34257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34258   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34259   float arg2 ;
34260   float arg3 ;
34261
34262   arg1 = (Dali::Actor *)jarg1;
34263   arg2 = (float)jarg2;
34264   arg3 = (float)jarg3;
34265   {
34266     try {
34267       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
34268     } catch (std::out_of_range& e) {
34269       {
34270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34271       };
34272     } catch (std::exception& e) {
34273       {
34274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34275       };
34276     } catch (Dali::DaliException e) {
34277       {
34278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34279       };
34280     } catch (...) {
34281       {
34282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34283       };
34284     }
34285   }
34286
34287 }
34288
34289
34290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34291   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34292   float arg2 ;
34293   float arg3 ;
34294   float arg4 ;
34295
34296   arg1 = (Dali::Actor *)jarg1;
34297   arg2 = (float)jarg2;
34298   arg3 = (float)jarg3;
34299   arg4 = (float)jarg4;
34300   {
34301     try {
34302       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
34303     } catch (std::out_of_range& e) {
34304       {
34305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34306       };
34307     } catch (std::exception& e) {
34308       {
34309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34310       };
34311     } catch (Dali::DaliException e) {
34312       {
34313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34314       };
34315     } catch (...) {
34316       {
34317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34318       };
34319     }
34320   }
34321
34322 }
34323
34324
34325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34326   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34327   Dali::Vector2 *arg2 = 0 ;
34328
34329   arg1 = (Dali::Actor *)jarg1;
34330   arg2 = (Dali::Vector2 *)jarg2;
34331   if (!arg2) {
34332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34333     return ;
34334   }
34335   {
34336     try {
34337       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
34338     } catch (std::out_of_range& e) {
34339       {
34340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34341       };
34342     } catch (std::exception& e) {
34343       {
34344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34345       };
34346     } catch (Dali::DaliException e) {
34347       {
34348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34349       };
34350     } catch (...) {
34351       {
34352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34353       };
34354     }
34355   }
34356
34357 }
34358
34359
34360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34361   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34362   Dali::Vector3 *arg2 = 0 ;
34363
34364   arg1 = (Dali::Actor *)jarg1;
34365   arg2 = (Dali::Vector3 *)jarg2;
34366   if (!arg2) {
34367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34368     return ;
34369   }
34370   {
34371     try {
34372       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
34373     } catch (std::out_of_range& e) {
34374       {
34375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34376       };
34377     } catch (std::exception& e) {
34378       {
34379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34380       };
34381     } catch (Dali::DaliException e) {
34382       {
34383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34384       };
34385     } catch (...) {
34386       {
34387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34388       };
34389     }
34390   }
34391
34392 }
34393
34394
34395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34396   void * jresult ;
34397   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34398   Dali::Vector3 result;
34399
34400   arg1 = (Dali::Actor *)jarg1;
34401   {
34402     try {
34403       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34404     } catch (std::out_of_range& e) {
34405       {
34406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34407       };
34408     } catch (std::exception& e) {
34409       {
34410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34411       };
34412     } catch (Dali::DaliException e) {
34413       {
34414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34415       };
34416     } catch (...) {
34417       {
34418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34419       };
34420     }
34421   }
34422
34423   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34424   return jresult;
34425 }
34426
34427
34428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34429   void * jresult ;
34430   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34431   Dali::Vector3 result;
34432
34433   arg1 = (Dali::Actor *)jarg1;
34434   {
34435     try {
34436       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
34437     } catch (std::out_of_range& e) {
34438       {
34439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34440       };
34441     } catch (std::exception& e) {
34442       {
34443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34444       };
34445     } catch (Dali::DaliException e) {
34446       {
34447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34448       };
34449     } catch (...) {
34450       {
34451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34452       };
34453     }
34454   }
34455
34456   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34457   return jresult;
34458 }
34459
34460
34461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34462   void * jresult ;
34463   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34464   Dali::Vector3 result;
34465
34466   arg1 = (Dali::Actor *)jarg1;
34467   {
34468     try {
34469       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34470     } catch (std::out_of_range& e) {
34471       {
34472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34473       };
34474     } catch (std::exception& e) {
34475       {
34476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34477       };
34478     } catch (Dali::DaliException e) {
34479       {
34480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34481       };
34482     } catch (...) {
34483       {
34484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34485       };
34486     }
34487   }
34488
34489   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34490   return jresult;
34491 }
34492
34493
34494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34495   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34496   float arg2 ;
34497   float arg3 ;
34498
34499   arg1 = (Dali::Actor *)jarg1;
34500   arg2 = (float)jarg2;
34501   arg3 = (float)jarg3;
34502   {
34503     try {
34504       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
34505     } catch (std::out_of_range& e) {
34506       {
34507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34508       };
34509     } catch (std::exception& e) {
34510       {
34511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34512       };
34513     } catch (Dali::DaliException e) {
34514       {
34515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34516       };
34517     } catch (...) {
34518       {
34519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34520       };
34521     }
34522   }
34523
34524 }
34525
34526
34527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34528   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34529   float arg2 ;
34530   float arg3 ;
34531   float arg4 ;
34532
34533   arg1 = (Dali::Actor *)jarg1;
34534   arg2 = (float)jarg2;
34535   arg3 = (float)jarg3;
34536   arg4 = (float)jarg4;
34537   {
34538     try {
34539       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
34540     } catch (std::out_of_range& e) {
34541       {
34542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34543       };
34544     } catch (std::exception& e) {
34545       {
34546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34547       };
34548     } catch (Dali::DaliException e) {
34549       {
34550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34551       };
34552     } catch (...) {
34553       {
34554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34555       };
34556     }
34557   }
34558
34559 }
34560
34561
34562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34563   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34564   Dali::Vector3 *arg2 = 0 ;
34565
34566   arg1 = (Dali::Actor *)jarg1;
34567   arg2 = (Dali::Vector3 *)jarg2;
34568   if (!arg2) {
34569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34570     return ;
34571   }
34572   {
34573     try {
34574       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
34575     } catch (std::out_of_range& e) {
34576       {
34577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34578       };
34579     } catch (std::exception& e) {
34580       {
34581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34582       };
34583     } catch (Dali::DaliException e) {
34584       {
34585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34586       };
34587     } catch (...) {
34588       {
34589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34590       };
34591     }
34592   }
34593
34594 }
34595
34596
34597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34598   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34599   float arg2 ;
34600
34601   arg1 = (Dali::Actor *)jarg1;
34602   arg2 = (float)jarg2;
34603   {
34604     try {
34605       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
34606     } catch (std::out_of_range& e) {
34607       {
34608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34609       };
34610     } catch (std::exception& e) {
34611       {
34612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34613       };
34614     } catch (Dali::DaliException e) {
34615       {
34616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34617       };
34618     } catch (...) {
34619       {
34620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34621       };
34622     }
34623   }
34624
34625 }
34626
34627
34628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34629   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34630   float arg2 ;
34631
34632   arg1 = (Dali::Actor *)jarg1;
34633   arg2 = (float)jarg2;
34634   {
34635     try {
34636       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
34637     } catch (std::out_of_range& e) {
34638       {
34639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34640       };
34641     } catch (std::exception& e) {
34642       {
34643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34644       };
34645     } catch (Dali::DaliException e) {
34646       {
34647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34648       };
34649     } catch (...) {
34650       {
34651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34652       };
34653     }
34654   }
34655
34656 }
34657
34658
34659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34660   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34661   float arg2 ;
34662
34663   arg1 = (Dali::Actor *)jarg1;
34664   arg2 = (float)jarg2;
34665   {
34666     try {
34667       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
34668     } catch (std::out_of_range& e) {
34669       {
34670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34671       };
34672     } catch (std::exception& e) {
34673       {
34674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34675       };
34676     } catch (Dali::DaliException e) {
34677       {
34678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34679       };
34680     } catch (...) {
34681       {
34682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34683       };
34684     }
34685   }
34686
34687 }
34688
34689
34690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34691   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34692   Dali::Vector3 *arg2 = 0 ;
34693
34694   arg1 = (Dali::Actor *)jarg1;
34695   arg2 = (Dali::Vector3 *)jarg2;
34696   if (!arg2) {
34697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34698     return ;
34699   }
34700   {
34701     try {
34702       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34703     } catch (std::out_of_range& e) {
34704       {
34705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34706       };
34707     } catch (std::exception& e) {
34708       {
34709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34710       };
34711     } catch (Dali::DaliException e) {
34712       {
34713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34714       };
34715     } catch (...) {
34716       {
34717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34718       };
34719     }
34720   }
34721
34722 }
34723
34724
34725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34726   void * jresult ;
34727   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34728   Dali::Vector3 result;
34729
34730   arg1 = (Dali::Actor *)jarg1;
34731   {
34732     try {
34733       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
34734     } catch (std::out_of_range& e) {
34735       {
34736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34737       };
34738     } catch (std::exception& e) {
34739       {
34740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34741       };
34742     } catch (Dali::DaliException e) {
34743       {
34744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34745       };
34746     } catch (...) {
34747       {
34748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34749       };
34750     }
34751   }
34752
34753   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34754   return jresult;
34755 }
34756
34757
34758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34759   void * jresult ;
34760   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34761   Dali::Vector3 result;
34762
34763   arg1 = (Dali::Actor *)jarg1;
34764   {
34765     try {
34766       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
34767     } catch (std::out_of_range& e) {
34768       {
34769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34770       };
34771     } catch (std::exception& e) {
34772       {
34773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34774       };
34775     } catch (Dali::DaliException e) {
34776       {
34777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34778       };
34779     } catch (...) {
34780       {
34781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34782       };
34783     }
34784   }
34785
34786   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34787   return jresult;
34788 }
34789
34790
34791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34792   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34793   bool arg2 ;
34794
34795   arg1 = (Dali::Actor *)jarg1;
34796   arg2 = jarg2 ? true : false;
34797   {
34798     try {
34799       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
34800     } catch (std::out_of_range& e) {
34801       {
34802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34803       };
34804     } catch (std::exception& e) {
34805       {
34806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34807       };
34808     } catch (Dali::DaliException e) {
34809       {
34810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34811       };
34812     } catch (...) {
34813       {
34814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34815       };
34816     }
34817   }
34818
34819 }
34820
34821
34822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34823   unsigned int jresult ;
34824   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34825   bool result;
34826
34827   arg1 = (Dali::Actor *)jarg1;
34828   {
34829     try {
34830       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
34831     } catch (std::out_of_range& e) {
34832       {
34833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34834       };
34835     } catch (std::exception& e) {
34836       {
34837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34838       };
34839     } catch (Dali::DaliException e) {
34840       {
34841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34842       };
34843     } catch (...) {
34844       {
34845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34846       };
34847     }
34848   }
34849
34850   jresult = result;
34851   return jresult;
34852 }
34853
34854
34855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34856   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34857   Dali::Degree *arg2 = 0 ;
34858   Dali::Vector3 *arg3 = 0 ;
34859
34860   arg1 = (Dali::Actor *)jarg1;
34861   arg2 = (Dali::Degree *)jarg2;
34862   if (!arg2) {
34863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34864     return ;
34865   }
34866   arg3 = (Dali::Vector3 *)jarg3;
34867   if (!arg3) {
34868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34869     return ;
34870   }
34871   {
34872     try {
34873       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34874     } catch (std::out_of_range& e) {
34875       {
34876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34877       };
34878     } catch (std::exception& e) {
34879       {
34880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34881       };
34882     } catch (Dali::DaliException e) {
34883       {
34884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34885       };
34886     } catch (...) {
34887       {
34888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34889       };
34890     }
34891   }
34892
34893 }
34894
34895
34896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34897   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34898   Dali::Radian *arg2 = 0 ;
34899   Dali::Vector3 *arg3 = 0 ;
34900
34901   arg1 = (Dali::Actor *)jarg1;
34902   arg2 = (Dali::Radian *)jarg2;
34903   if (!arg2) {
34904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34905     return ;
34906   }
34907   arg3 = (Dali::Vector3 *)jarg3;
34908   if (!arg3) {
34909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34910     return ;
34911   }
34912   {
34913     try {
34914       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34915     } catch (std::out_of_range& e) {
34916       {
34917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34918       };
34919     } catch (std::exception& e) {
34920       {
34921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34922       };
34923     } catch (Dali::DaliException e) {
34924       {
34925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34926       };
34927     } catch (...) {
34928       {
34929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34930       };
34931     }
34932   }
34933
34934 }
34935
34936
34937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34938   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34939   Dali::Quaternion *arg2 = 0 ;
34940
34941   arg1 = (Dali::Actor *)jarg1;
34942   arg2 = (Dali::Quaternion *)jarg2;
34943   if (!arg2) {
34944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34945     return ;
34946   }
34947   {
34948     try {
34949       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
34950     } catch (std::out_of_range& e) {
34951       {
34952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34953       };
34954     } catch (std::exception& e) {
34955       {
34956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34957       };
34958     } catch (Dali::DaliException e) {
34959       {
34960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34961       };
34962     } catch (...) {
34963       {
34964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34965       };
34966     }
34967   }
34968
34969 }
34970
34971
34972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34973   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34974   Dali::Degree *arg2 = 0 ;
34975   Dali::Vector3 *arg3 = 0 ;
34976
34977   arg1 = (Dali::Actor *)jarg1;
34978   arg2 = (Dali::Degree *)jarg2;
34979   if (!arg2) {
34980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34981     return ;
34982   }
34983   arg3 = (Dali::Vector3 *)jarg3;
34984   if (!arg3) {
34985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34986     return ;
34987   }
34988   {
34989     try {
34990       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34991     } catch (std::out_of_range& e) {
34992       {
34993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34994       };
34995     } catch (std::exception& e) {
34996       {
34997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34998       };
34999     } catch (Dali::DaliException e) {
35000       {
35001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35002       };
35003     } catch (...) {
35004       {
35005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35006       };
35007     }
35008   }
35009
35010 }
35011
35012
35013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35014   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35015   Dali::Radian *arg2 = 0 ;
35016   Dali::Vector3 *arg3 = 0 ;
35017
35018   arg1 = (Dali::Actor *)jarg1;
35019   arg2 = (Dali::Radian *)jarg2;
35020   if (!arg2) {
35021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35022     return ;
35023   }
35024   arg3 = (Dali::Vector3 *)jarg3;
35025   if (!arg3) {
35026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35027     return ;
35028   }
35029   {
35030     try {
35031       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35032     } catch (std::out_of_range& e) {
35033       {
35034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35035       };
35036     } catch (std::exception& e) {
35037       {
35038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35039       };
35040     } catch (Dali::DaliException e) {
35041       {
35042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35043       };
35044     } catch (...) {
35045       {
35046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35047       };
35048     }
35049   }
35050
35051 }
35052
35053
35054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35055   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35056   Dali::Quaternion *arg2 = 0 ;
35057
35058   arg1 = (Dali::Actor *)jarg1;
35059   arg2 = (Dali::Quaternion *)jarg2;
35060   if (!arg2) {
35061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35062     return ;
35063   }
35064   {
35065     try {
35066       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35067     } catch (std::out_of_range& e) {
35068       {
35069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35070       };
35071     } catch (std::exception& e) {
35072       {
35073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35074       };
35075     } catch (Dali::DaliException e) {
35076       {
35077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35078       };
35079     } catch (...) {
35080       {
35081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35082       };
35083     }
35084   }
35085
35086 }
35087
35088
35089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35090   void * jresult ;
35091   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35092   Dali::Quaternion result;
35093
35094   arg1 = (Dali::Actor *)jarg1;
35095   {
35096     try {
35097       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
35098     } catch (std::out_of_range& e) {
35099       {
35100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35101       };
35102     } catch (std::exception& e) {
35103       {
35104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35105       };
35106     } catch (Dali::DaliException e) {
35107       {
35108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35109       };
35110     } catch (...) {
35111       {
35112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35113       };
35114     }
35115   }
35116
35117   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35118   return jresult;
35119 }
35120
35121
35122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35123   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35124   bool arg2 ;
35125
35126   arg1 = (Dali::Actor *)jarg1;
35127   arg2 = jarg2 ? true : false;
35128   {
35129     try {
35130       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
35131     } catch (std::out_of_range& e) {
35132       {
35133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35134       };
35135     } catch (std::exception& e) {
35136       {
35137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35138       };
35139     } catch (Dali::DaliException e) {
35140       {
35141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35142       };
35143     } catch (...) {
35144       {
35145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35146       };
35147     }
35148   }
35149
35150 }
35151
35152
35153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35154   unsigned int jresult ;
35155   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35156   bool result;
35157
35158   arg1 = (Dali::Actor *)jarg1;
35159   {
35160     try {
35161       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
35162     } catch (std::out_of_range& e) {
35163       {
35164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35165       };
35166     } catch (std::exception& e) {
35167       {
35168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35169       };
35170     } catch (Dali::DaliException e) {
35171       {
35172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35173       };
35174     } catch (...) {
35175       {
35176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35177       };
35178     }
35179   }
35180
35181   jresult = result;
35182   return jresult;
35183 }
35184
35185
35186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35187   void * jresult ;
35188   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35189   Dali::Quaternion result;
35190
35191   arg1 = (Dali::Actor *)jarg1;
35192   {
35193     try {
35194       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
35195     } catch (std::out_of_range& e) {
35196       {
35197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35198       };
35199     } catch (std::exception& e) {
35200       {
35201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35202       };
35203     } catch (Dali::DaliException e) {
35204       {
35205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35206       };
35207     } catch (...) {
35208       {
35209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35210       };
35211     }
35212   }
35213
35214   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35215   return jresult;
35216 }
35217
35218
35219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35220   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35221   float arg2 ;
35222
35223   arg1 = (Dali::Actor *)jarg1;
35224   arg2 = (float)jarg2;
35225   {
35226     try {
35227       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
35228     } catch (std::out_of_range& e) {
35229       {
35230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35231       };
35232     } catch (std::exception& e) {
35233       {
35234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35235       };
35236     } catch (Dali::DaliException e) {
35237       {
35238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35239       };
35240     } catch (...) {
35241       {
35242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35243       };
35244     }
35245   }
35246
35247 }
35248
35249
35250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35251   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35252   float arg2 ;
35253   float arg3 ;
35254   float arg4 ;
35255
35256   arg1 = (Dali::Actor *)jarg1;
35257   arg2 = (float)jarg2;
35258   arg3 = (float)jarg3;
35259   arg4 = (float)jarg4;
35260   {
35261     try {
35262       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
35263     } catch (std::out_of_range& e) {
35264       {
35265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35266       };
35267     } catch (std::exception& e) {
35268       {
35269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35270       };
35271     } catch (Dali::DaliException e) {
35272       {
35273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35274       };
35275     } catch (...) {
35276       {
35277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35278       };
35279     }
35280   }
35281
35282 }
35283
35284
35285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35286   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35287   Dali::Vector3 *arg2 = 0 ;
35288
35289   arg1 = (Dali::Actor *)jarg1;
35290   arg2 = (Dali::Vector3 *)jarg2;
35291   if (!arg2) {
35292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35293     return ;
35294   }
35295   {
35296     try {
35297       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
35298     } catch (std::out_of_range& e) {
35299       {
35300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35301       };
35302     } catch (std::exception& e) {
35303       {
35304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35305       };
35306     } catch (Dali::DaliException e) {
35307       {
35308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35309       };
35310     } catch (...) {
35311       {
35312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35313       };
35314     }
35315   }
35316
35317 }
35318
35319
35320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35321   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35322   Dali::Vector3 *arg2 = 0 ;
35323
35324   arg1 = (Dali::Actor *)jarg1;
35325   arg2 = (Dali::Vector3 *)jarg2;
35326   if (!arg2) {
35327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35328     return ;
35329   }
35330   {
35331     try {
35332       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35333     } catch (std::out_of_range& e) {
35334       {
35335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35336       };
35337     } catch (std::exception& e) {
35338       {
35339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35340       };
35341     } catch (Dali::DaliException e) {
35342       {
35343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35344       };
35345     } catch (...) {
35346       {
35347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35348       };
35349     }
35350   }
35351
35352 }
35353
35354
35355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35356   void * jresult ;
35357   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35358   Dali::Vector3 result;
35359
35360   arg1 = (Dali::Actor *)jarg1;
35361   {
35362     try {
35363       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
35364     } catch (std::out_of_range& e) {
35365       {
35366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35367       };
35368     } catch (std::exception& e) {
35369       {
35370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35371       };
35372     } catch (Dali::DaliException e) {
35373       {
35374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35375       };
35376     } catch (...) {
35377       {
35378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35379       };
35380     }
35381   }
35382
35383   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35384   return jresult;
35385 }
35386
35387
35388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35389   void * jresult ;
35390   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35391   Dali::Vector3 result;
35392
35393   arg1 = (Dali::Actor *)jarg1;
35394   {
35395     try {
35396       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
35397     } catch (std::out_of_range& e) {
35398       {
35399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35400       };
35401     } catch (std::exception& e) {
35402       {
35403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35404       };
35405     } catch (Dali::DaliException e) {
35406       {
35407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35408       };
35409     } catch (...) {
35410       {
35411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35412       };
35413     }
35414   }
35415
35416   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35417   return jresult;
35418 }
35419
35420
35421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35422   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35423   bool arg2 ;
35424
35425   arg1 = (Dali::Actor *)jarg1;
35426   arg2 = jarg2 ? true : false;
35427   {
35428     try {
35429       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
35430     } catch (std::out_of_range& e) {
35431       {
35432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35433       };
35434     } catch (std::exception& e) {
35435       {
35436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35437       };
35438     } catch (Dali::DaliException e) {
35439       {
35440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35441       };
35442     } catch (...) {
35443       {
35444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35445       };
35446     }
35447   }
35448
35449 }
35450
35451
35452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35453   unsigned int jresult ;
35454   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35455   bool result;
35456
35457   arg1 = (Dali::Actor *)jarg1;
35458   {
35459     try {
35460       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
35461     } catch (std::out_of_range& e) {
35462       {
35463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35464       };
35465     } catch (std::exception& e) {
35466       {
35467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35468       };
35469     } catch (Dali::DaliException e) {
35470       {
35471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35472       };
35473     } catch (...) {
35474       {
35475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35476       };
35477     }
35478   }
35479
35480   jresult = result;
35481   return jresult;
35482 }
35483
35484
35485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35486   void * jresult ;
35487   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35488   Dali::Matrix result;
35489
35490   arg1 = (Dali::Actor *)jarg1;
35491   {
35492     try {
35493       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
35494     } catch (std::out_of_range& e) {
35495       {
35496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35497       };
35498     } catch (std::exception& e) {
35499       {
35500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35501       };
35502     } catch (Dali::DaliException e) {
35503       {
35504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35505       };
35506     } catch (...) {
35507       {
35508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35509       };
35510     }
35511   }
35512
35513   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35514   return jresult;
35515 }
35516
35517
35518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35519   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35520   bool arg2 ;
35521
35522   arg1 = (Dali::Actor *)jarg1;
35523   arg2 = jarg2 ? true : false;
35524   {
35525     try {
35526       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
35527     } catch (std::out_of_range& e) {
35528       {
35529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35530       };
35531     } catch (std::exception& e) {
35532       {
35533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35534       };
35535     } catch (Dali::DaliException e) {
35536       {
35537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35538       };
35539     } catch (...) {
35540       {
35541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35542       };
35543     }
35544   }
35545
35546 }
35547
35548
35549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35550   unsigned int jresult ;
35551   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35552   bool result;
35553
35554   arg1 = (Dali::Actor *)jarg1;
35555   {
35556     try {
35557       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
35558     } catch (std::out_of_range& e) {
35559       {
35560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35561       };
35562     } catch (std::exception& e) {
35563       {
35564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35565       };
35566     } catch (Dali::DaliException e) {
35567       {
35568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35569       };
35570     } catch (...) {
35571       {
35572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35573       };
35574     }
35575   }
35576
35577   jresult = result;
35578   return jresult;
35579 }
35580
35581
35582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35583   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35584   float arg2 ;
35585
35586   arg1 = (Dali::Actor *)jarg1;
35587   arg2 = (float)jarg2;
35588   {
35589     try {
35590       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
35591     } catch (std::out_of_range& e) {
35592       {
35593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35594       };
35595     } catch (std::exception& e) {
35596       {
35597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35598       };
35599     } catch (Dali::DaliException e) {
35600       {
35601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35602       };
35603     } catch (...) {
35604       {
35605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35606       };
35607     }
35608   }
35609
35610 }
35611
35612
35613 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35614   float jresult ;
35615   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35616   float result;
35617
35618   arg1 = (Dali::Actor *)jarg1;
35619   {
35620     try {
35621       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
35622     } catch (std::out_of_range& e) {
35623       {
35624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35625       };
35626     } catch (std::exception& e) {
35627       {
35628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35629       };
35630     } catch (Dali::DaliException e) {
35631       {
35632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35633       };
35634     } catch (...) {
35635       {
35636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35637       };
35638     }
35639   }
35640
35641   jresult = result;
35642   return jresult;
35643 }
35644
35645
35646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35647   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35648   Dali::Vector4 *arg2 = 0 ;
35649
35650   arg1 = (Dali::Actor *)jarg1;
35651   arg2 = (Dali::Vector4 *)jarg2;
35652   if (!arg2) {
35653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35654     return ;
35655   }
35656   {
35657     try {
35658       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
35659     } catch (std::out_of_range& e) {
35660       {
35661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35662       };
35663     } catch (std::exception& e) {
35664       {
35665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35666       };
35667     } catch (Dali::DaliException e) {
35668       {
35669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35670       };
35671     } catch (...) {
35672       {
35673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35674       };
35675     }
35676   }
35677
35678 }
35679
35680
35681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35682   void * jresult ;
35683   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35684   Dali::Vector4 result;
35685
35686   arg1 = (Dali::Actor *)jarg1;
35687   {
35688     try {
35689       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
35690     } catch (std::out_of_range& e) {
35691       {
35692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35693       };
35694     } catch (std::exception& e) {
35695       {
35696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35697       };
35698     } catch (Dali::DaliException e) {
35699       {
35700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35701       };
35702     } catch (...) {
35703       {
35704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35705       };
35706     }
35707   }
35708
35709   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35710   return jresult;
35711 }
35712
35713
35714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35715   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35716   Dali::ColorMode arg2 ;
35717
35718   arg1 = (Dali::Actor *)jarg1;
35719   arg2 = (Dali::ColorMode)jarg2;
35720   {
35721     try {
35722       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
35723     } catch (std::out_of_range& e) {
35724       {
35725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35726       };
35727     } catch (std::exception& e) {
35728       {
35729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35730       };
35731     } catch (Dali::DaliException e) {
35732       {
35733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35734       };
35735     } catch (...) {
35736       {
35737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35738       };
35739     }
35740   }
35741
35742 }
35743
35744
35745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35746   int jresult ;
35747   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35748   Dali::ColorMode result;
35749
35750   arg1 = (Dali::Actor *)jarg1;
35751   {
35752     try {
35753       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
35754     } catch (std::out_of_range& e) {
35755       {
35756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35757       };
35758     } catch (std::exception& e) {
35759       {
35760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35761       };
35762     } catch (Dali::DaliException e) {
35763       {
35764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35765       };
35766     } catch (...) {
35767       {
35768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35769       };
35770     }
35771   }
35772
35773   jresult = (int)result;
35774   return jresult;
35775 }
35776
35777
35778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35779   void * jresult ;
35780   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35781   Dali::Vector4 result;
35782
35783   arg1 = (Dali::Actor *)jarg1;
35784   {
35785     try {
35786       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
35787     } catch (std::out_of_range& e) {
35788       {
35789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35790       };
35791     } catch (std::exception& e) {
35792       {
35793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35794       };
35795     } catch (Dali::DaliException e) {
35796       {
35797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35798       };
35799     } catch (...) {
35800       {
35801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35802       };
35803     }
35804   }
35805
35806   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35807   return jresult;
35808 }
35809
35810
35811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35812   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35813   Dali::DrawMode::Type arg2 ;
35814
35815   arg1 = (Dali::Actor *)jarg1;
35816   arg2 = (Dali::DrawMode::Type)jarg2;
35817   {
35818     try {
35819       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
35820     } catch (std::out_of_range& e) {
35821       {
35822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35823       };
35824     } catch (std::exception& e) {
35825       {
35826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35827       };
35828     } catch (Dali::DaliException e) {
35829       {
35830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35831       };
35832     } catch (...) {
35833       {
35834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35835       };
35836     }
35837   }
35838
35839 }
35840
35841
35842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35843   int jresult ;
35844   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35845   Dali::DrawMode::Type result;
35846
35847   arg1 = (Dali::Actor *)jarg1;
35848   {
35849     try {
35850       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
35851     } catch (std::out_of_range& e) {
35852       {
35853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35854       };
35855     } catch (std::exception& e) {
35856       {
35857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35858       };
35859     } catch (Dali::DaliException e) {
35860       {
35861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35862       };
35863     } catch (...) {
35864       {
35865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35866       };
35867     }
35868   }
35869
35870   jresult = (int)result;
35871   return jresult;
35872 }
35873
35874
35875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35876   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35877   bool arg2 ;
35878
35879   arg1 = (Dali::Actor *)jarg1;
35880   arg2 = jarg2 ? true : false;
35881   {
35882     try {
35883       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
35884     } catch (std::out_of_range& e) {
35885       {
35886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35887       };
35888     } catch (std::exception& e) {
35889       {
35890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35891       };
35892     } catch (Dali::DaliException e) {
35893       {
35894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35895       };
35896     } catch (...) {
35897       {
35898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35899       };
35900     }
35901   }
35902
35903 }
35904
35905
35906 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35907   unsigned int jresult ;
35908   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35909   bool result;
35910
35911   arg1 = (Dali::Actor *)jarg1;
35912   {
35913     try {
35914       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
35915     } catch (std::out_of_range& e) {
35916       {
35917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35918       };
35919     } catch (std::exception& e) {
35920       {
35921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35922       };
35923     } catch (Dali::DaliException e) {
35924       {
35925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35926       };
35927     } catch (...) {
35928       {
35929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35930       };
35931     }
35932   }
35933
35934   jresult = result;
35935   return jresult;
35936 }
35937
35938
35939 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35940   unsigned int jresult ;
35941   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35942   float *arg2 = 0 ;
35943   float *arg3 = 0 ;
35944   float arg4 ;
35945   float arg5 ;
35946   bool result;
35947
35948   arg1 = (Dali::Actor *)jarg1;
35949   arg2 = (float *)jarg2;
35950   arg3 = (float *)jarg3;
35951   arg4 = (float)jarg4;
35952   arg5 = (float)jarg5;
35953   {
35954     try {
35955       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35956     } catch (std::out_of_range& e) {
35957       {
35958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35959       };
35960     } catch (std::exception& e) {
35961       {
35962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35963       };
35964     } catch (Dali::DaliException e) {
35965       {
35966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35967       };
35968     } catch (...) {
35969       {
35970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35971       };
35972     }
35973   }
35974
35975   jresult = result;
35976   return jresult;
35977 }
35978
35979
35980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
35981   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35982   bool arg2 ;
35983
35984   arg1 = (Dali::Actor *)jarg1;
35985   arg2 = jarg2 ? true : false;
35986   {
35987     try {
35988       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
35989     } catch (std::out_of_range& e) {
35990       {
35991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35992       };
35993     } catch (std::exception& e) {
35994       {
35995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35996       };
35997     } catch (Dali::DaliException e) {
35998       {
35999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36000       };
36001     } catch (...) {
36002       {
36003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36004       };
36005     }
36006   }
36007
36008 }
36009
36010
36011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36012   unsigned int jresult ;
36013   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36014   bool result;
36015
36016   arg1 = (Dali::Actor *)jarg1;
36017   {
36018     try {
36019       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
36020     } catch (std::out_of_range& e) {
36021       {
36022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36023       };
36024     } catch (std::exception& e) {
36025       {
36026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36027       };
36028     } catch (Dali::DaliException e) {
36029       {
36030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36031       };
36032     } catch (...) {
36033       {
36034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36035       };
36036     }
36037   }
36038
36039   jresult = result;
36040   return jresult;
36041 }
36042
36043
36044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36045   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36046   bool arg2 ;
36047
36048   arg1 = (Dali::Actor *)jarg1;
36049   arg2 = jarg2 ? true : false;
36050   {
36051     try {
36052       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
36053     } catch (std::out_of_range& e) {
36054       {
36055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36056       };
36057     } catch (std::exception& e) {
36058       {
36059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36060       };
36061     } catch (Dali::DaliException e) {
36062       {
36063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36064       };
36065     } catch (...) {
36066       {
36067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36068       };
36069     }
36070   }
36071
36072 }
36073
36074
36075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36076   unsigned int jresult ;
36077   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36078   bool result;
36079
36080   arg1 = (Dali::Actor *)jarg1;
36081   {
36082     try {
36083       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
36084     } catch (std::out_of_range& e) {
36085       {
36086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36087       };
36088     } catch (std::exception& e) {
36089       {
36090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36091       };
36092     } catch (Dali::DaliException e) {
36093       {
36094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36095       };
36096     } catch (...) {
36097       {
36098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36099       };
36100     }
36101   }
36102
36103   jresult = result;
36104   return jresult;
36105 }
36106
36107
36108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36109   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36110   Dali::ResizePolicy::Type arg2 ;
36111   Dali::Dimension::Type arg3 ;
36112
36113   arg1 = (Dali::Actor *)jarg1;
36114   arg2 = (Dali::ResizePolicy::Type)jarg2;
36115   arg3 = (Dali::Dimension::Type)jarg3;
36116   {
36117     try {
36118       (arg1)->SetResizePolicy(arg2,arg3);
36119     } catch (std::out_of_range& e) {
36120       {
36121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36122       };
36123     } catch (std::exception& e) {
36124       {
36125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36126       };
36127     } catch (Dali::DaliException e) {
36128       {
36129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36130       };
36131     } catch (...) {
36132       {
36133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36134       };
36135     }
36136   }
36137
36138 }
36139
36140
36141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36142   int jresult ;
36143   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36144   Dali::Dimension::Type arg2 ;
36145   Dali::ResizePolicy::Type result;
36146
36147   arg1 = (Dali::Actor *)jarg1;
36148   arg2 = (Dali::Dimension::Type)jarg2;
36149   {
36150     try {
36151       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36152     } catch (std::out_of_range& e) {
36153       {
36154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36155       };
36156     } catch (std::exception& e) {
36157       {
36158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36159       };
36160     } catch (Dali::DaliException e) {
36161       {
36162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36163       };
36164     } catch (...) {
36165       {
36166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36167       };
36168     }
36169   }
36170
36171   jresult = (int)result;
36172   return jresult;
36173 }
36174
36175
36176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36177   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36178   Dali::SizeScalePolicy::Type arg2 ;
36179
36180   arg1 = (Dali::Actor *)jarg1;
36181   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36182   {
36183     try {
36184       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
36185     } catch (std::out_of_range& e) {
36186       {
36187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36188       };
36189     } catch (std::exception& e) {
36190       {
36191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36192       };
36193     } catch (Dali::DaliException e) {
36194       {
36195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36196       };
36197     } catch (...) {
36198       {
36199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36200       };
36201     }
36202   }
36203
36204 }
36205
36206
36207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36208   int jresult ;
36209   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36210   Dali::SizeScalePolicy::Type result;
36211
36212   arg1 = (Dali::Actor *)jarg1;
36213   {
36214     try {
36215       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
36216     } catch (std::out_of_range& e) {
36217       {
36218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36219       };
36220     } catch (std::exception& e) {
36221       {
36222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36223       };
36224     } catch (Dali::DaliException e) {
36225       {
36226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36227       };
36228     } catch (...) {
36229       {
36230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36231       };
36232     }
36233   }
36234
36235   jresult = (int)result;
36236   return jresult;
36237 }
36238
36239
36240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36241   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36242   Dali::Vector3 *arg2 = 0 ;
36243
36244   arg1 = (Dali::Actor *)jarg1;
36245   arg2 = (Dali::Vector3 *)jarg2;
36246   if (!arg2) {
36247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36248     return ;
36249   }
36250   {
36251     try {
36252       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
36253     } catch (std::out_of_range& e) {
36254       {
36255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36256       };
36257     } catch (std::exception& e) {
36258       {
36259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36260       };
36261     } catch (Dali::DaliException e) {
36262       {
36263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36264       };
36265     } catch (...) {
36266       {
36267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36268       };
36269     }
36270   }
36271
36272 }
36273
36274
36275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36276   void * jresult ;
36277   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36278   Dali::Vector3 result;
36279
36280   arg1 = (Dali::Actor *)jarg1;
36281   {
36282     try {
36283       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
36284     } catch (std::out_of_range& e) {
36285       {
36286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36287       };
36288     } catch (std::exception& e) {
36289       {
36290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36291       };
36292     } catch (Dali::DaliException e) {
36293       {
36294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36295       };
36296     } catch (...) {
36297       {
36298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36299       };
36300     }
36301   }
36302
36303   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36304   return jresult;
36305 }
36306
36307
36308 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36309   float jresult ;
36310   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36311   float arg2 ;
36312   float result;
36313
36314   arg1 = (Dali::Actor *)jarg1;
36315   arg2 = (float)jarg2;
36316   {
36317     try {
36318       result = (float)(arg1)->GetHeightForWidth(arg2);
36319     } catch (std::out_of_range& e) {
36320       {
36321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36322       };
36323     } catch (std::exception& e) {
36324       {
36325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36326       };
36327     } catch (Dali::DaliException e) {
36328       {
36329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36330       };
36331     } catch (...) {
36332       {
36333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36334       };
36335     }
36336   }
36337
36338   jresult = result;
36339   return jresult;
36340 }
36341
36342
36343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36344   float jresult ;
36345   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36346   float arg2 ;
36347   float result;
36348
36349   arg1 = (Dali::Actor *)jarg1;
36350   arg2 = (float)jarg2;
36351   {
36352     try {
36353       result = (float)(arg1)->GetWidthForHeight(arg2);
36354     } catch (std::out_of_range& e) {
36355       {
36356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36357       };
36358     } catch (std::exception& e) {
36359       {
36360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36361       };
36362     } catch (Dali::DaliException e) {
36363       {
36364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36365       };
36366     } catch (...) {
36367       {
36368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36369       };
36370     }
36371   }
36372
36373   jresult = result;
36374   return jresult;
36375 }
36376
36377
36378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36379   float jresult ;
36380   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36381   Dali::Dimension::Type arg2 ;
36382   float result;
36383
36384   arg1 = (Dali::Actor *)jarg1;
36385   arg2 = (Dali::Dimension::Type)jarg2;
36386   {
36387     try {
36388       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36389     } catch (std::out_of_range& e) {
36390       {
36391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36392       };
36393     } catch (std::exception& e) {
36394       {
36395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36396       };
36397     } catch (Dali::DaliException e) {
36398       {
36399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36400       };
36401     } catch (...) {
36402       {
36403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36404       };
36405     }
36406   }
36407
36408   jresult = result;
36409   return jresult;
36410 }
36411
36412
36413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36414   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36415   Dali::Padding *arg2 = 0 ;
36416
36417   arg1 = (Dali::Actor *)jarg1;
36418   arg2 = (Dali::Padding *)jarg2;
36419   if (!arg2) {
36420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36421     return ;
36422   }
36423   {
36424     try {
36425       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
36426     } catch (std::out_of_range& e) {
36427       {
36428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36429       };
36430     } catch (std::exception& e) {
36431       {
36432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36433       };
36434     } catch (Dali::DaliException e) {
36435       {
36436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36437       };
36438     } catch (...) {
36439       {
36440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36441       };
36442     }
36443   }
36444
36445 }
36446
36447
36448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36449   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36450   Dali::Padding *arg2 = 0 ;
36451
36452   arg1 = (Dali::Actor *)jarg1;
36453   arg2 = (Dali::Padding *)jarg2;
36454   if (!arg2) {
36455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36456     return ;
36457   }
36458   {
36459     try {
36460       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
36461     } catch (std::out_of_range& e) {
36462       {
36463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36464       };
36465     } catch (std::exception& e) {
36466       {
36467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36468       };
36469     } catch (Dali::DaliException e) {
36470       {
36471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36472       };
36473     } catch (...) {
36474       {
36475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36476       };
36477     }
36478   }
36479
36480 }
36481
36482
36483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36484   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36485   Dali::Vector2 *arg2 = 0 ;
36486
36487   arg1 = (Dali::Actor *)jarg1;
36488   arg2 = (Dali::Vector2 *)jarg2;
36489   if (!arg2) {
36490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36491     return ;
36492   }
36493   {
36494     try {
36495       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36496     } catch (std::out_of_range& e) {
36497       {
36498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36499       };
36500     } catch (std::exception& e) {
36501       {
36502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36503       };
36504     } catch (Dali::DaliException e) {
36505       {
36506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36507       };
36508     } catch (...) {
36509       {
36510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36511       };
36512     }
36513   }
36514
36515 }
36516
36517
36518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36519   void * jresult ;
36520   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36521   Dali::Vector2 result;
36522
36523   arg1 = (Dali::Actor *)jarg1;
36524   {
36525     try {
36526       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
36527     } catch (std::out_of_range& e) {
36528       {
36529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36530       };
36531     } catch (std::exception& e) {
36532       {
36533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36534       };
36535     } catch (Dali::DaliException e) {
36536       {
36537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36538       };
36539     } catch (...) {
36540       {
36541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36542       };
36543     }
36544   }
36545
36546   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36547   return jresult;
36548 }
36549
36550
36551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36552   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36553   Dali::Vector2 *arg2 = 0 ;
36554
36555   arg1 = (Dali::Actor *)jarg1;
36556   arg2 = (Dali::Vector2 *)jarg2;
36557   if (!arg2) {
36558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36559     return ;
36560   }
36561   {
36562     try {
36563       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36564     } catch (std::out_of_range& e) {
36565       {
36566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36567       };
36568     } catch (std::exception& e) {
36569       {
36570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36571       };
36572     } catch (Dali::DaliException e) {
36573       {
36574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36575       };
36576     } catch (...) {
36577       {
36578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36579       };
36580     }
36581   }
36582
36583 }
36584
36585
36586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36587   void * jresult ;
36588   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36589   Dali::Vector2 result;
36590
36591   arg1 = (Dali::Actor *)jarg1;
36592   {
36593     try {
36594       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
36595     } catch (std::out_of_range& e) {
36596       {
36597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36598       };
36599     } catch (std::exception& e) {
36600       {
36601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36602       };
36603     } catch (Dali::DaliException e) {
36604       {
36605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36606       };
36607     } catch (...) {
36608       {
36609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36610       };
36611     }
36612   }
36613
36614   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36615   return jresult;
36616 }
36617
36618
36619 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36620   int jresult ;
36621   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36622   int result;
36623
36624   arg1 = (Dali::Actor *)jarg1;
36625   {
36626     try {
36627       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
36628       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36629     } catch (std::out_of_range& e) {
36630       {
36631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36632       };
36633     } catch (std::exception& e) {
36634       {
36635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36636       };
36637     } catch (Dali::DaliException e) {
36638       {
36639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36640       };
36641     } catch (...) {
36642       {
36643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36644       };
36645     }
36646   }
36647
36648   jresult = result;
36649   return jresult;
36650 }
36651
36652
36653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36654   unsigned int jresult ;
36655   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36656   Dali::Renderer *arg2 = 0 ;
36657   unsigned int result;
36658
36659   arg1 = (Dali::Actor *)jarg1;
36660   arg2 = (Dali::Renderer *)jarg2;
36661   if (!arg2) {
36662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36663     return 0;
36664   }
36665   {
36666     try {
36667       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36668     } catch (std::out_of_range& e) {
36669       {
36670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36671       };
36672     } catch (std::exception& e) {
36673       {
36674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36675       };
36676     } catch (Dali::DaliException e) {
36677       {
36678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36679       };
36680     } catch (...) {
36681       {
36682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36683       };
36684     }
36685   }
36686
36687   jresult = result;
36688   return jresult;
36689 }
36690
36691
36692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36693   unsigned int jresult ;
36694   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36695   unsigned int result;
36696
36697   arg1 = (Dali::Actor *)jarg1;
36698   {
36699     try {
36700       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36701     } catch (std::out_of_range& e) {
36702       {
36703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36704       };
36705     } catch (std::exception& e) {
36706       {
36707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36708       };
36709     } catch (Dali::DaliException e) {
36710       {
36711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36712       };
36713     } catch (...) {
36714       {
36715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36716       };
36717     }
36718   }
36719
36720   jresult = result;
36721   return jresult;
36722 }
36723
36724
36725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36726   void * jresult ;
36727   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36728   unsigned int arg2 ;
36729   Dali::Renderer result;
36730
36731   arg1 = (Dali::Actor *)jarg1;
36732   arg2 = (unsigned int)jarg2;
36733   {
36734     try {
36735       result = (arg1)->GetRendererAt(arg2);
36736     } catch (std::out_of_range& e) {
36737       {
36738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36739       };
36740     } catch (std::exception& e) {
36741       {
36742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36743       };
36744     } catch (Dali::DaliException e) {
36745       {
36746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36747       };
36748     } catch (...) {
36749       {
36750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36751       };
36752     }
36753   }
36754
36755   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36756   return jresult;
36757 }
36758
36759
36760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36761   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36762   Dali::Renderer *arg2 = 0 ;
36763
36764   arg1 = (Dali::Actor *)jarg1;
36765   arg2 = (Dali::Renderer *)jarg2;
36766   if (!arg2) {
36767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36768     return ;
36769   }
36770   {
36771     try {
36772       (arg1)->RemoveRenderer(*arg2);
36773     } catch (std::out_of_range& e) {
36774       {
36775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36776       };
36777     } catch (std::exception& e) {
36778       {
36779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36780       };
36781     } catch (Dali::DaliException e) {
36782       {
36783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36784       };
36785     } catch (...) {
36786       {
36787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36788       };
36789     }
36790   }
36791
36792 }
36793
36794
36795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36796   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36797   unsigned int arg2 ;
36798
36799   arg1 = (Dali::Actor *)jarg1;
36800   arg2 = (unsigned int)jarg2;
36801   {
36802     try {
36803       (arg1)->RemoveRenderer(arg2);
36804     } catch (std::out_of_range& e) {
36805       {
36806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36807       };
36808     } catch (std::exception& e) {
36809       {
36810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36811       };
36812     } catch (Dali::DaliException e) {
36813       {
36814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36815       };
36816     } catch (...) {
36817       {
36818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36819       };
36820     }
36821   }
36822
36823 }
36824
36825
36826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36827   void * jresult ;
36828   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36829   Dali::Actor::TouchEventSignalType *result = 0 ;
36830
36831   arg1 = (Dali::Actor *)jarg1;
36832   {
36833     try {
36834       result = (Dali::Actor::TouchEventSignalType *) &(arg1)->TouchSignal();
36835     } catch (std::out_of_range& e) {
36836       {
36837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36838       };
36839     } catch (std::exception& e) {
36840       {
36841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36842       };
36843     } catch (Dali::DaliException e) {
36844       {
36845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36846       };
36847     } catch (...) {
36848       {
36849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36850       };
36851     }
36852   }
36853
36854   jresult = (void *)result;
36855   return jresult;
36856 }
36857
36858
36859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36860   void * jresult ;
36861   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36862   Dali::Actor::HoverSignalType *result = 0 ;
36863
36864   arg1 = (Dali::Actor *)jarg1;
36865   {
36866     try {
36867       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36868     } catch (std::out_of_range& e) {
36869       {
36870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36871       };
36872     } catch (std::exception& e) {
36873       {
36874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36875       };
36876     } catch (Dali::DaliException e) {
36877       {
36878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36879       };
36880     } catch (...) {
36881       {
36882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36883       };
36884     }
36885   }
36886
36887   jresult = (void *)result;
36888   return jresult;
36889 }
36890
36891
36892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36893   void * jresult ;
36894   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36895   Dali::Actor::WheelEventSignalType *result = 0 ;
36896
36897   arg1 = (Dali::Actor *)jarg1;
36898   {
36899     try {
36900       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36901     } catch (std::out_of_range& e) {
36902       {
36903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36904       };
36905     } catch (std::exception& e) {
36906       {
36907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36908       };
36909     } catch (Dali::DaliException e) {
36910       {
36911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36912       };
36913     } catch (...) {
36914       {
36915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36916       };
36917     }
36918   }
36919
36920   jresult = (void *)result;
36921   return jresult;
36922 }
36923
36924
36925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnSceneSignal(void * jarg1) {
36926   void * jresult ;
36927   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36928   Dali::Actor::OnSceneSignalType *result = 0 ;
36929
36930   arg1 = (Dali::Actor *)jarg1;
36931   {
36932     try {
36933       result = (Dali::Actor::OnSceneSignalType *) &(arg1)->OnSceneSignal();
36934     } catch (std::out_of_range& e) {
36935       {
36936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36937       };
36938     } catch (std::exception& e) {
36939       {
36940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36941       };
36942     } catch (Dali::DaliException e) {
36943       {
36944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36945       };
36946     } catch (...) {
36947       {
36948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36949       };
36950     }
36951   }
36952
36953   jresult = (void *)result;
36954   return jresult;
36955 }
36956
36957
36958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffSceneSignal(void * jarg1) {
36959   void * jresult ;
36960   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36961   Dali::Actor::OffSceneSignalType *result = 0 ;
36962
36963   arg1 = (Dali::Actor *)jarg1;
36964   {
36965     try {
36966       result = (Dali::Actor::OffSceneSignalType *) &(arg1)->OffSceneSignal();
36967     } catch (std::out_of_range& e) {
36968       {
36969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36970       };
36971     } catch (std::exception& e) {
36972       {
36973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36974       };
36975     } catch (Dali::DaliException e) {
36976       {
36977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36978       };
36979     } catch (...) {
36980       {
36981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36982       };
36983     }
36984   }
36985
36986   jresult = (void *)result;
36987   return jresult;
36988 }
36989
36990
36991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
36992   void * jresult ;
36993   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36994   Dali::Actor::OnRelayoutSignalType *result = 0 ;
36995
36996   arg1 = (Dali::Actor *)jarg1;
36997   {
36998     try {
36999       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37000     } catch (std::out_of_range& e) {
37001       {
37002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37003       };
37004     } catch (std::exception& e) {
37005       {
37006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37007       };
37008     } catch (Dali::DaliException e) {
37009       {
37010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37011       };
37012     } catch (...) {
37013       {
37014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37015       };
37016     }
37017   }
37018
37019   jresult = (void *)result;
37020   return jresult;
37021 }
37022
37023
37024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37025   Dali::Actor *arg1 = 0 ;
37026
37027   arg1 = (Dali::Actor *)jarg1;
37028   if (!arg1) {
37029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37030     return ;
37031   }
37032   {
37033     try {
37034       Dali::UnparentAndReset(*arg1);
37035     } catch (std::out_of_range& e) {
37036       {
37037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37038       };
37039     } catch (std::exception& e) {
37040       {
37041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37042       };
37043     } catch (Dali::DaliException e) {
37044       {
37045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37046       };
37047     } catch (...) {
37048       {
37049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37050       };
37051     }
37052   }
37053
37054 }
37055
37056
37057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37058   int jresult ;
37059   int result;
37060
37061   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37062   jresult = (int)result;
37063   return jresult;
37064 }
37065
37066
37067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37068   int jresult ;
37069   int result;
37070
37071   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37072   jresult = (int)result;
37073   return jresult;
37074 }
37075
37076
37077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37078   int jresult ;
37079   int result;
37080
37081   result = (int)Dali::Layer::Property::BEHAVIOR;
37082   jresult = (int)result;
37083   return jresult;
37084 }
37085
37086
37087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37088   void * jresult ;
37089   Dali::Layer::Property *result = 0 ;
37090
37091   {
37092     try {
37093       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37094     } catch (std::out_of_range& e) {
37095       {
37096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37097       };
37098     } catch (std::exception& e) {
37099       {
37100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37101       };
37102     } catch (Dali::DaliException e) {
37103       {
37104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37105       };
37106     } catch (...) {
37107       {
37108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37109       };
37110     }
37111   }
37112
37113   jresult = (void *)result;
37114   return jresult;
37115 }
37116
37117
37118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37119   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37120
37121   arg1 = (Dali::Layer::Property *)jarg1;
37122   {
37123     try {
37124       delete arg1;
37125     } catch (std::out_of_range& e) {
37126       {
37127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37128       };
37129     } catch (std::exception& e) {
37130       {
37131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37132       };
37133     } catch (Dali::DaliException e) {
37134       {
37135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37136       };
37137     } catch (...) {
37138       {
37139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37140       };
37141     }
37142   }
37143
37144 }
37145
37146
37147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37148   void * jresult ;
37149   Dali::Layer *result = 0 ;
37150
37151   {
37152     try {
37153       result = (Dali::Layer *)new Dali::Layer();
37154     } catch (std::out_of_range& e) {
37155       {
37156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37157       };
37158     } catch (std::exception& e) {
37159       {
37160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37161       };
37162     } catch (Dali::DaliException e) {
37163       {
37164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37165       };
37166     } catch (...) {
37167       {
37168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37169       };
37170     }
37171   }
37172
37173   jresult = (void *)result;
37174   return jresult;
37175 }
37176
37177
37178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37179   void * jresult ;
37180   Dali::Layer result;
37181
37182   {
37183     try {
37184       result = Dali::Layer::New();
37185     } catch (std::out_of_range& e) {
37186       {
37187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37188       };
37189     } catch (std::exception& e) {
37190       {
37191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37192       };
37193     } catch (Dali::DaliException e) {
37194       {
37195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37196       };
37197     } catch (...) {
37198       {
37199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37200       };
37201     }
37202   }
37203
37204   jresult = new Dali::Layer((const Dali::Layer &)result);
37205   return jresult;
37206 }
37207
37208
37209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37210   void * jresult ;
37211   Dali::BaseHandle arg1 ;
37212   Dali::BaseHandle *argp1 ;
37213   Dali::Layer result;
37214
37215   argp1 = (Dali::BaseHandle *)jarg1;
37216   if (!argp1) {
37217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37218     return 0;
37219   }
37220   arg1 = *argp1;
37221   {
37222     try {
37223       result = Dali::Layer::DownCast(arg1);
37224     } catch (std::out_of_range& e) {
37225       {
37226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37227       };
37228     } catch (std::exception& e) {
37229       {
37230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37231       };
37232     } catch (Dali::DaliException e) {
37233       {
37234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37235       };
37236     } catch (...) {
37237       {
37238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37239       };
37240     }
37241   }
37242
37243   jresult = new Dali::Layer((const Dali::Layer &)result);
37244   return jresult;
37245 }
37246
37247
37248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37249   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37250
37251   arg1 = (Dali::Layer *)jarg1;
37252   {
37253     try {
37254       delete arg1;
37255     } catch (std::out_of_range& e) {
37256       {
37257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37258       };
37259     } catch (std::exception& e) {
37260       {
37261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37262       };
37263     } catch (Dali::DaliException e) {
37264       {
37265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37266       };
37267     } catch (...) {
37268       {
37269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37270       };
37271     }
37272   }
37273
37274 }
37275
37276
37277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37278   void * jresult ;
37279   Dali::Layer *arg1 = 0 ;
37280   Dali::Layer *result = 0 ;
37281
37282   arg1 = (Dali::Layer *)jarg1;
37283   if (!arg1) {
37284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37285     return 0;
37286   }
37287   {
37288     try {
37289       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37290     } catch (std::out_of_range& e) {
37291       {
37292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37293       };
37294     } catch (std::exception& e) {
37295       {
37296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37297       };
37298     } catch (Dali::DaliException e) {
37299       {
37300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37301       };
37302     } catch (...) {
37303       {
37304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37305       };
37306     }
37307   }
37308
37309   jresult = (void *)result;
37310   return jresult;
37311 }
37312
37313
37314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37315   void * jresult ;
37316   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37317   Dali::Layer *arg2 = 0 ;
37318   Dali::Layer *result = 0 ;
37319
37320   arg1 = (Dali::Layer *)jarg1;
37321   arg2 = (Dali::Layer *)jarg2;
37322   if (!arg2) {
37323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37324     return 0;
37325   }
37326   {
37327     try {
37328       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37329     } catch (std::out_of_range& e) {
37330       {
37331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37332       };
37333     } catch (std::exception& e) {
37334       {
37335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37336       };
37337     } catch (Dali::DaliException e) {
37338       {
37339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37340       };
37341     } catch (...) {
37342       {
37343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37344       };
37345     }
37346   }
37347
37348   jresult = (void *)result;
37349   return jresult;
37350 }
37351
37352
37353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37354   unsigned int jresult ;
37355   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37356   unsigned int result;
37357
37358   arg1 = (Dali::Layer *)jarg1;
37359   {
37360     try {
37361       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
37362     } catch (std::out_of_range& e) {
37363       {
37364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37365       };
37366     } catch (std::exception& e) {
37367       {
37368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37369       };
37370     } catch (Dali::DaliException e) {
37371       {
37372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37373       };
37374     } catch (...) {
37375       {
37376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37377       };
37378     }
37379   }
37380
37381   jresult = result;
37382   return jresult;
37383 }
37384
37385
37386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37387   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37388
37389   arg1 = (Dali::Layer *)jarg1;
37390   {
37391     try {
37392       (arg1)->Raise();
37393     } catch (std::out_of_range& e) {
37394       {
37395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37396       };
37397     } catch (std::exception& e) {
37398       {
37399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37400       };
37401     } catch (Dali::DaliException e) {
37402       {
37403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37404       };
37405     } catch (...) {
37406       {
37407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37408       };
37409     }
37410   }
37411
37412 }
37413
37414
37415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37416   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37417
37418   arg1 = (Dali::Layer *)jarg1;
37419   {
37420     try {
37421       (arg1)->Lower();
37422     } catch (std::out_of_range& e) {
37423       {
37424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37425       };
37426     } catch (std::exception& e) {
37427       {
37428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37429       };
37430     } catch (Dali::DaliException e) {
37431       {
37432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37433       };
37434     } catch (...) {
37435       {
37436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37437       };
37438     }
37439   }
37440
37441 }
37442
37443
37444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37445   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37446   Dali::Layer arg2 ;
37447   Dali::Layer *argp2 ;
37448
37449   arg1 = (Dali::Layer *)jarg1;
37450   argp2 = (Dali::Layer *)jarg2;
37451   if (!argp2) {
37452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37453     return ;
37454   }
37455   arg2 = *argp2;
37456   {
37457     try {
37458       (arg1)->RaiseAbove(arg2);
37459     } catch (std::out_of_range& e) {
37460       {
37461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37462       };
37463     } catch (std::exception& e) {
37464       {
37465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37466       };
37467     } catch (Dali::DaliException e) {
37468       {
37469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37470       };
37471     } catch (...) {
37472       {
37473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37474       };
37475     }
37476   }
37477
37478 }
37479
37480
37481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37482   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37483   Dali::Layer arg2 ;
37484   Dali::Layer *argp2 ;
37485
37486   arg1 = (Dali::Layer *)jarg1;
37487   argp2 = (Dali::Layer *)jarg2;
37488   if (!argp2) {
37489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37490     return ;
37491   }
37492   arg2 = *argp2;
37493   {
37494     try {
37495       (arg1)->LowerBelow(arg2);
37496     } catch (std::out_of_range& e) {
37497       {
37498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37499       };
37500     } catch (std::exception& e) {
37501       {
37502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37503       };
37504     } catch (Dali::DaliException e) {
37505       {
37506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37507       };
37508     } catch (...) {
37509       {
37510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37511       };
37512     }
37513   }
37514
37515 }
37516
37517
37518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37519   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37520
37521   arg1 = (Dali::Layer *)jarg1;
37522   {
37523     try {
37524       (arg1)->RaiseToTop();
37525     } catch (std::out_of_range& e) {
37526       {
37527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37528       };
37529     } catch (std::exception& e) {
37530       {
37531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37532       };
37533     } catch (Dali::DaliException e) {
37534       {
37535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37536       };
37537     } catch (...) {
37538       {
37539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37540       };
37541     }
37542   }
37543
37544 }
37545
37546
37547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37548   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37549
37550   arg1 = (Dali::Layer *)jarg1;
37551   {
37552     try {
37553       (arg1)->LowerToBottom();
37554     } catch (std::out_of_range& e) {
37555       {
37556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37557       };
37558     } catch (std::exception& e) {
37559       {
37560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37561       };
37562     } catch (Dali::DaliException e) {
37563       {
37564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37565       };
37566     } catch (...) {
37567       {
37568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37569       };
37570     }
37571   }
37572
37573 }
37574
37575
37576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37577   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37578   Dali::Layer arg2 ;
37579   Dali::Layer *argp2 ;
37580
37581   arg1 = (Dali::Layer *)jarg1;
37582   argp2 = (Dali::Layer *)jarg2;
37583   if (!argp2) {
37584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37585     return ;
37586   }
37587   arg2 = *argp2;
37588   {
37589     try {
37590       (arg1)->MoveAbove(arg2);
37591     } catch (std::out_of_range& e) {
37592       {
37593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37594       };
37595     } catch (std::exception& e) {
37596       {
37597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37598       };
37599     } catch (Dali::DaliException e) {
37600       {
37601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37602       };
37603     } catch (...) {
37604       {
37605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37606       };
37607     }
37608   }
37609
37610 }
37611
37612
37613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37614   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37615   Dali::Layer arg2 ;
37616   Dali::Layer *argp2 ;
37617
37618   arg1 = (Dali::Layer *)jarg1;
37619   argp2 = (Dali::Layer *)jarg2;
37620   if (!argp2) {
37621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37622     return ;
37623   }
37624   arg2 = *argp2;
37625   {
37626     try {
37627       (arg1)->MoveBelow(arg2);
37628     } catch (std::out_of_range& e) {
37629       {
37630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37631       };
37632     } catch (std::exception& e) {
37633       {
37634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37635       };
37636     } catch (Dali::DaliException e) {
37637       {
37638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37639       };
37640     } catch (...) {
37641       {
37642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37643       };
37644     }
37645   }
37646
37647 }
37648
37649
37650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37651   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37652   Dali::Layer::Behavior arg2 ;
37653
37654   arg1 = (Dali::Layer *)jarg1;
37655   arg2 = (Dali::Layer::Behavior)jarg2;
37656   {
37657     try {
37658       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
37659     } catch (std::out_of_range& e) {
37660       {
37661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37662       };
37663     } catch (std::exception& e) {
37664       {
37665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37666       };
37667     } catch (Dali::DaliException e) {
37668       {
37669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37670       };
37671     } catch (...) {
37672       {
37673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37674       };
37675     }
37676   }
37677
37678 }
37679
37680
37681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37682   int jresult ;
37683   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37684   Dali::Layer::Behavior result;
37685
37686   arg1 = (Dali::Layer *)jarg1;
37687   {
37688     try {
37689       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
37690     } catch (std::out_of_range& e) {
37691       {
37692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37693       };
37694     } catch (std::exception& e) {
37695       {
37696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37697       };
37698     } catch (Dali::DaliException e) {
37699       {
37700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37701       };
37702     } catch (...) {
37703       {
37704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37705       };
37706     }
37707   }
37708
37709   jresult = (int)result;
37710   return jresult;
37711 }
37712
37713
37714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37715   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37716   bool arg2 ;
37717
37718   arg1 = (Dali::Layer *)jarg1;
37719   arg2 = jarg2 ? true : false;
37720   {
37721     try {
37722       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
37723     } catch (std::out_of_range& e) {
37724       {
37725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37726       };
37727     } catch (std::exception& e) {
37728       {
37729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37730       };
37731     } catch (Dali::DaliException e) {
37732       {
37733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37734       };
37735     } catch (...) {
37736       {
37737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37738       };
37739     }
37740   }
37741
37742 }
37743
37744
37745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37746   unsigned int jresult ;
37747   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37748   bool result;
37749
37750   arg1 = (Dali::Layer *)jarg1;
37751   {
37752     try {
37753       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
37754     } catch (std::out_of_range& e) {
37755       {
37756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37757       };
37758     } catch (std::exception& e) {
37759       {
37760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37761       };
37762     } catch (Dali::DaliException e) {
37763       {
37764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37765       };
37766     } catch (...) {
37767       {
37768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37769       };
37770     }
37771   }
37772
37773   jresult = result;
37774   return jresult;
37775 }
37776
37777
37778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37779   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37780   int arg2 ;
37781   int arg3 ;
37782   int arg4 ;
37783   int arg5 ;
37784
37785   arg1 = (Dali::Layer *)jarg1;
37786   arg2 = (int)jarg2;
37787   arg3 = (int)jarg3;
37788   arg4 = (int)jarg4;
37789   arg5 = (int)jarg5;
37790   {
37791     try {
37792       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
37793     } catch (std::out_of_range& e) {
37794       {
37795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37796       };
37797     } catch (std::exception& e) {
37798       {
37799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37800       };
37801     } catch (Dali::DaliException e) {
37802       {
37803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37804       };
37805     } catch (...) {
37806       {
37807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37808       };
37809     }
37810   }
37811
37812 }
37813
37814
37815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37816   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37817   Dali::ClippingBox arg2 ;
37818   Dali::ClippingBox *argp2 ;
37819
37820   arg1 = (Dali::Layer *)jarg1;
37821   argp2 = (Dali::ClippingBox *)jarg2;
37822   if (!argp2) {
37823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37824     return ;
37825   }
37826   arg2 = *argp2;
37827   {
37828     try {
37829       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
37830     } catch (std::out_of_range& e) {
37831       {
37832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37833       };
37834     } catch (std::exception& e) {
37835       {
37836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37837       };
37838     } catch (Dali::DaliException e) {
37839       {
37840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37841       };
37842     } catch (...) {
37843       {
37844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37845       };
37846     }
37847   }
37848
37849 }
37850
37851
37852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37853   void * jresult ;
37854   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37855   Dali::ClippingBox result;
37856
37857   arg1 = (Dali::Layer *)jarg1;
37858   {
37859     try {
37860       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
37861     } catch (std::out_of_range& e) {
37862       {
37863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37864       };
37865     } catch (std::exception& e) {
37866       {
37867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37868       };
37869     } catch (Dali::DaliException e) {
37870       {
37871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37872       };
37873     } catch (...) {
37874       {
37875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37876       };
37877     }
37878   }
37879
37880   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37881   return jresult;
37882 }
37883
37884
37885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37886   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37887   bool arg2 ;
37888
37889   arg1 = (Dali::Layer *)jarg1;
37890   arg2 = jarg2 ? true : false;
37891   {
37892     try {
37893       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
37894     } catch (std::out_of_range& e) {
37895       {
37896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37897       };
37898     } catch (std::exception& e) {
37899       {
37900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37901       };
37902     } catch (Dali::DaliException e) {
37903       {
37904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37905       };
37906     } catch (...) {
37907       {
37908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37909       };
37910     }
37911   }
37912
37913 }
37914
37915
37916 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37917   unsigned int jresult ;
37918   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37919   bool result;
37920
37921   arg1 = (Dali::Layer *)jarg1;
37922   {
37923     try {
37924       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
37925     } catch (std::out_of_range& e) {
37926       {
37927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37928       };
37929     } catch (std::exception& e) {
37930       {
37931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37932       };
37933     } catch (Dali::DaliException e) {
37934       {
37935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37936       };
37937     } catch (...) {
37938       {
37939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37940       };
37941     }
37942   }
37943
37944   jresult = result;
37945   return jresult;
37946 }
37947
37948
37949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
37950   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37951   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
37952
37953   arg1 = (Dali::Layer *)jarg1;
37954   arg2 = (Dali::Layer::SortFunctionType)jarg2;
37955   {
37956     try {
37957       (arg1)->SetSortFunction(arg2);
37958     } catch (std::out_of_range& e) {
37959       {
37960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37961       };
37962     } catch (std::exception& e) {
37963       {
37964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37965       };
37966     } catch (Dali::DaliException e) {
37967       {
37968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37969       };
37970     } catch (...) {
37971       {
37972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37973       };
37974     }
37975   }
37976
37977 }
37978
37979
37980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
37981   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37982   bool arg2 ;
37983
37984   arg1 = (Dali::Layer *)jarg1;
37985   arg2 = jarg2 ? true : false;
37986   {
37987     try {
37988       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
37989     } catch (std::out_of_range& e) {
37990       {
37991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37992       };
37993     } catch (std::exception& e) {
37994       {
37995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37996       };
37997     } catch (Dali::DaliException e) {
37998       {
37999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38000       };
38001     } catch (...) {
38002       {
38003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38004       };
38005     }
38006   }
38007
38008 }
38009
38010
38011 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38012   unsigned int jresult ;
38013   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38014   bool result;
38015
38016   arg1 = (Dali::Layer *)jarg1;
38017   {
38018     try {
38019       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
38020     } catch (std::out_of_range& e) {
38021       {
38022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38023       };
38024     } catch (std::exception& e) {
38025       {
38026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38027       };
38028     } catch (Dali::DaliException e) {
38029       {
38030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38031       };
38032     } catch (...) {
38033       {
38034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38035       };
38036     }
38037   }
38038
38039   jresult = result;
38040   return jresult;
38041 }
38042
38043
38044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38045   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38046   bool arg2 ;
38047
38048   arg1 = (Dali::Layer *)jarg1;
38049   arg2 = jarg2 ? true : false;
38050   {
38051     try {
38052       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
38053     } catch (std::out_of_range& e) {
38054       {
38055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38056       };
38057     } catch (std::exception& e) {
38058       {
38059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38060       };
38061     } catch (Dali::DaliException e) {
38062       {
38063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38064       };
38065     } catch (...) {
38066       {
38067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38068       };
38069     }
38070   }
38071
38072 }
38073
38074
38075 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38076   unsigned int jresult ;
38077   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38078   bool result;
38079
38080   arg1 = (Dali::Layer *)jarg1;
38081   {
38082     try {
38083       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
38084     } catch (std::out_of_range& e) {
38085       {
38086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38087       };
38088     } catch (std::exception& e) {
38089       {
38090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38091       };
38092     } catch (Dali::DaliException e) {
38093       {
38094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38095       };
38096     } catch (...) {
38097       {
38098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38099       };
38100     }
38101   }
38102
38103   jresult = result;
38104   return jresult;
38105 }
38106
38107
38108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38109   void * jresult ;
38110   Dali::Stage result;
38111
38112   {
38113     try {
38114       result = Dali::Stage::GetCurrent();
38115     } catch (std::out_of_range& e) {
38116       {
38117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38118       };
38119     } catch (std::exception& e) {
38120       {
38121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38122       };
38123     } catch (Dali::DaliException e) {
38124       {
38125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38126       };
38127     } catch (...) {
38128       {
38129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38130       };
38131     }
38132   }
38133
38134   jresult = new Dali::Stage((const Dali::Stage &)result);
38135   return jresult;
38136 }
38137
38138
38139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38140   unsigned int jresult ;
38141   bool result;
38142
38143   {
38144     try {
38145       result = (bool)Dali::Stage::IsInstalled();
38146     } catch (std::out_of_range& e) {
38147       {
38148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38149       };
38150     } catch (std::exception& e) {
38151       {
38152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38153       };
38154     } catch (Dali::DaliException e) {
38155       {
38156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38157       };
38158     } catch (...) {
38159       {
38160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38161       };
38162     }
38163   }
38164
38165   jresult = result;
38166   return jresult;
38167 }
38168
38169
38170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38171   void * jresult ;
38172   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38173   Dali::Vector2 result;
38174
38175   arg1 = (Dali::Stage *)jarg1;
38176   {
38177     try {
38178       result = ((Dali::Stage const *)arg1)->GetDpi();
38179     } catch (std::out_of_range& e) {
38180       {
38181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38182       };
38183     } catch (std::exception& e) {
38184       {
38185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38186       };
38187     } catch (Dali::DaliException e) {
38188       {
38189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38190       };
38191     } catch (...) {
38192       {
38193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38194       };
38195     }
38196   }
38197
38198   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38199   return jresult;
38200 }
38201
38202
38203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38204   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38205   float arg2 ;
38206
38207   arg1 = (Dali::Stage *)jarg1;
38208   arg2 = (float)jarg2;
38209   {
38210     try {
38211       (arg1)->KeepRendering(arg2);
38212     } catch (std::out_of_range& e) {
38213       {
38214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38215       };
38216     } catch (std::exception& e) {
38217       {
38218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38219       };
38220     } catch (Dali::DaliException e) {
38221       {
38222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38223       };
38224     } catch (...) {
38225       {
38226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38227       };
38228     }
38229   }
38230
38231 }
38232
38233
38234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38235   void * jresult ;
38236   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38237   Dali::Stage::KeyEventSignalType *result = 0 ;
38238
38239   arg1 = (Dali::Stage *)jarg1;
38240   {
38241     try {
38242       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38243     } catch (std::out_of_range& e) {
38244       {
38245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38246       };
38247     } catch (std::exception& e) {
38248       {
38249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38250       };
38251     } catch (Dali::DaliException e) {
38252       {
38253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38254       };
38255     } catch (...) {
38256       {
38257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38258       };
38259     }
38260   }
38261
38262   jresult = (void *)result;
38263   return jresult;
38264 }
38265
38266
38267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38268   void * jresult ;
38269   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38270   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38271
38272   arg1 = (Dali::Stage *)jarg1;
38273   {
38274     try {
38275       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38276     } catch (std::out_of_range& e) {
38277       {
38278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38279       };
38280     } catch (std::exception& e) {
38281       {
38282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38283       };
38284     } catch (Dali::DaliException e) {
38285       {
38286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38287       };
38288     } catch (...) {
38289       {
38290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38291       };
38292     }
38293   }
38294
38295   jresult = (void *)result;
38296   return jresult;
38297 }
38298
38299
38300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38301   void * jresult ;
38302   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38303   Dali::Stage::TouchSignalType *result = 0 ;
38304
38305   arg1 = (Dali::Stage *)jarg1;
38306   {
38307     try {
38308       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38309     } catch (std::out_of_range& e) {
38310       {
38311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38312       };
38313     } catch (std::exception& e) {
38314       {
38315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38316       };
38317     } catch (Dali::DaliException e) {
38318       {
38319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38320       };
38321     } catch (...) {
38322       {
38323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38324       };
38325     }
38326   }
38327
38328   jresult = (void *)result;
38329   return jresult;
38330 }
38331
38332
38333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38334   void * jresult ;
38335   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38336   Dali::Stage::WheelEventSignalType *result = 0 ;
38337
38338   arg1 = (Dali::Stage *)jarg1;
38339   {
38340     try {
38341       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38342     } catch (std::out_of_range& e) {
38343       {
38344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38345       };
38346     } catch (std::exception& e) {
38347       {
38348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38349       };
38350     } catch (Dali::DaliException e) {
38351       {
38352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38353       };
38354     } catch (...) {
38355       {
38356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38357       };
38358     }
38359   }
38360
38361   jresult = (void *)result;
38362   return jresult;
38363 }
38364
38365
38366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38367   void * jresult ;
38368   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38369   Dali::Stage::ContextStatusSignal *result = 0 ;
38370
38371   arg1 = (Dali::Stage *)jarg1;
38372   {
38373     try {
38374       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38375     } catch (std::out_of_range& e) {
38376       {
38377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38378       };
38379     } catch (std::exception& e) {
38380       {
38381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38382       };
38383     } catch (Dali::DaliException e) {
38384       {
38385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38386       };
38387     } catch (...) {
38388       {
38389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38390       };
38391     }
38392   }
38393
38394   jresult = (void *)result;
38395   return jresult;
38396 }
38397
38398
38399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38400   void * jresult ;
38401   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38402   Dali::Stage::ContextStatusSignal *result = 0 ;
38403
38404   arg1 = (Dali::Stage *)jarg1;
38405   {
38406     try {
38407       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38408     } catch (std::out_of_range& e) {
38409       {
38410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38411       };
38412     } catch (std::exception& e) {
38413       {
38414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38415       };
38416     } catch (Dali::DaliException e) {
38417       {
38418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38419       };
38420     } catch (...) {
38421       {
38422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38423       };
38424     }
38425   }
38426
38427   jresult = (void *)result;
38428   return jresult;
38429 }
38430
38431
38432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38433   void * jresult ;
38434   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38435   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38436
38437   arg1 = (Dali::Stage *)jarg1;
38438   {
38439     try {
38440       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
38441     } catch (std::out_of_range& e) {
38442       {
38443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38444       };
38445     } catch (std::exception& e) {
38446       {
38447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38448       };
38449     } catch (Dali::DaliException e) {
38450       {
38451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38452       };
38453     } catch (...) {
38454       {
38455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38456       };
38457     }
38458   }
38459
38460   jresult = (void *)result;
38461   return jresult;
38462 }
38463
38464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
38465   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38466   Dali::DevelStage::Rendering arg2 ;
38467
38468   arg1 = (Dali::Stage *)jarg1;
38469   arg2 = (Dali::DevelStage::Rendering)jarg2;
38470   {
38471     try {
38472       DevelStage::SetRenderingBehavior(*arg1,arg2);
38473     } catch (std::out_of_range& e) {
38474       {
38475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38476       };
38477     } catch (std::exception& e) {
38478       {
38479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38480       };
38481     } catch (Dali::DaliException e) {
38482       {
38483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38484       };
38485     } catch (...) {
38486       {
38487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38488       };
38489     }
38490   }
38491
38492 }
38493
38494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
38495
38496   int jresult ;
38497   int result ;
38498   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38499
38500   arg1 = (Dali::Stage *)jarg1;
38501   {
38502     try {
38503       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
38504     } catch (std::out_of_range& e) {
38505       {
38506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38507       };
38508     } catch (std::exception& e) {
38509       {
38510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38511       };
38512     } catch (Dali::DaliException e) {
38513       {
38514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38515       };
38516     } catch (...) {
38517       {
38518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38519       };
38520     }
38521   }
38522
38523   jresult = result;
38524   return jresult;
38525 }
38526
38527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
38528   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38529
38530   arg1 = (Dali::RelayoutContainer *)jarg1;
38531   {
38532     try {
38533       delete arg1;
38534     } catch (std::out_of_range& e) {
38535       {
38536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38537       };
38538     } catch (std::exception& e) {
38539       {
38540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38541       };
38542     } catch (Dali::DaliException e) {
38543       {
38544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38545       };
38546     } catch (...) {
38547       {
38548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38549       };
38550     }
38551   }
38552
38553 }
38554
38555
38556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
38557   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38558   Dali::Actor *arg2 = 0 ;
38559   Dali::Vector2 *arg3 = 0 ;
38560
38561   arg1 = (Dali::RelayoutContainer *)jarg1;
38562   arg2 = (Dali::Actor *)jarg2;
38563   if (!arg2) {
38564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38565     return ;
38566   }
38567   arg3 = (Dali::Vector2 *)jarg3;
38568   if (!arg3) {
38569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38570     return ;
38571   }
38572   {
38573     try {
38574       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
38575     } catch (std::out_of_range& e) {
38576       {
38577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38578       };
38579     } catch (std::exception& e) {
38580       {
38581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38582       };
38583     } catch (Dali::DaliException e) {
38584       {
38585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38586       };
38587     } catch (...) {
38588       {
38589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38590       };
38591     }
38592   }
38593
38594 }
38595
38596
38597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
38598   void * jresult ;
38599   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38600   Dali::CustomActor result;
38601
38602   arg1 = (Dali::CustomActorImpl *)jarg1;
38603   {
38604     try {
38605       result = ((Dali::CustomActorImpl const *)arg1)->Self();
38606     } catch (std::out_of_range& e) {
38607       {
38608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38609       };
38610     } catch (std::exception& e) {
38611       {
38612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38613       };
38614     } catch (Dali::DaliException e) {
38615       {
38616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38617       };
38618     } catch (...) {
38619       {
38620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38621       };
38622     }
38623   }
38624
38625   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
38626   return jresult;
38627 }
38628
38629
38630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneConnection(void * jarg1, int jarg2) {
38631   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38632   int arg2 ;
38633
38634   arg1 = (Dali::CustomActorImpl *)jarg1;
38635   arg2 = (int)jarg2;
38636   {
38637     try {
38638       (arg1)->OnSceneConnection(arg2);
38639     } catch (std::out_of_range& e) {
38640       {
38641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38642       };
38643     } catch (std::exception& e) {
38644       {
38645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38646       };
38647     } catch (Dali::DaliException e) {
38648       {
38649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38650       };
38651     } catch (...) {
38652       {
38653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38654       };
38655     }
38656   }
38657
38658 }
38659
38660
38661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSceneDisconnection(void * jarg1) {
38662   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38663
38664   arg1 = (Dali::CustomActorImpl *)jarg1;
38665   {
38666     try {
38667       (arg1)->OnSceneDisconnection();
38668     } catch (std::out_of_range& e) {
38669       {
38670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38671       };
38672     } catch (std::exception& e) {
38673       {
38674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38675       };
38676     } catch (Dali::DaliException e) {
38677       {
38678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38679       };
38680     } catch (...) {
38681       {
38682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38683       };
38684     }
38685   }
38686
38687 }
38688
38689
38690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
38691   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38692   Dali::Actor *arg2 = 0 ;
38693
38694   arg1 = (Dali::CustomActorImpl *)jarg1;
38695   arg2 = (Dali::Actor *)jarg2;
38696   if (!arg2) {
38697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38698     return ;
38699   }
38700   {
38701     try {
38702       (arg1)->OnChildAdd(*arg2);
38703     } catch (std::out_of_range& e) {
38704       {
38705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38706       };
38707     } catch (std::exception& e) {
38708       {
38709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38710       };
38711     } catch (Dali::DaliException e) {
38712       {
38713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38714       };
38715     } catch (...) {
38716       {
38717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38718       };
38719     }
38720   }
38721
38722 }
38723
38724
38725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
38726   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38727   Dali::Actor *arg2 = 0 ;
38728
38729   arg1 = (Dali::CustomActorImpl *)jarg1;
38730   arg2 = (Dali::Actor *)jarg2;
38731   if (!arg2) {
38732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38733     return ;
38734   }
38735   {
38736     try {
38737       (arg1)->OnChildRemove(*arg2);
38738     } catch (std::out_of_range& e) {
38739       {
38740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38741       };
38742     } catch (std::exception& e) {
38743       {
38744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38745       };
38746     } catch (Dali::DaliException e) {
38747       {
38748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38749       };
38750     } catch (...) {
38751       {
38752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38753       };
38754     }
38755   }
38756
38757 }
38758
38759
38760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
38761   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38762   Dali::Property::Index arg2 ;
38763   Dali::Property::Value arg3 ;
38764   Dali::Property::Value *argp3 ;
38765
38766   arg1 = (Dali::CustomActorImpl *)jarg1;
38767   arg2 = (Dali::Property::Index)jarg2;
38768   argp3 = (Dali::Property::Value *)jarg3;
38769   if (!argp3) {
38770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
38771     return ;
38772   }
38773   arg3 = *argp3;
38774   {
38775     try {
38776       (arg1)->OnPropertySet(arg2,arg3);
38777     } catch (std::out_of_range& e) {
38778       {
38779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38780       };
38781     } catch (std::exception& e) {
38782       {
38783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38784       };
38785     } catch (Dali::DaliException e) {
38786       {
38787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38788       };
38789     } catch (...) {
38790       {
38791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38792       };
38793     }
38794   }
38795
38796 }
38797
38798
38799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
38800   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38801   Dali::Vector3 *arg2 = 0 ;
38802
38803   arg1 = (Dali::CustomActorImpl *)jarg1;
38804   arg2 = (Dali::Vector3 *)jarg2;
38805   if (!arg2) {
38806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38807     return ;
38808   }
38809   {
38810     try {
38811       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
38812     } catch (std::out_of_range& e) {
38813       {
38814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38815       };
38816     } catch (std::exception& e) {
38817       {
38818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38819       };
38820     } catch (Dali::DaliException e) {
38821       {
38822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38823       };
38824     } catch (...) {
38825       {
38826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38827       };
38828     }
38829   }
38830
38831 }
38832
38833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
38834   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38835   Dali::Animation *arg2 = 0 ;
38836   Dali::Vector3 *arg3 = 0 ;
38837
38838   arg1 = (Dali::CustomActorImpl *)jarg1;
38839   arg2 = (Dali::Animation *)jarg2;
38840   if (!arg2) {
38841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
38842     return ;
38843   }
38844   arg3 = (Dali::Vector3 *)jarg3;
38845   if (!arg3) {
38846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38847     return ;
38848   }
38849   {
38850     try {
38851       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
38852     } catch (std::out_of_range& e) {
38853       {
38854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38855       };
38856     } catch (std::exception& e) {
38857       {
38858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38859       };
38860     } catch (Dali::DaliException e) {
38861       {
38862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38863       };
38864     } catch (...) {
38865       {
38866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38867       };
38868     }
38869   }
38870 }
38871
38872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
38873   unsigned int jresult ;
38874   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38875   Dali::HoverEvent *arg2 = 0 ;
38876   bool result;
38877
38878   arg1 = (Dali::CustomActorImpl *)jarg1;
38879   arg2 = (Dali::HoverEvent *)jarg2;
38880   if (!arg2) {
38881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
38882     return 0;
38883   }
38884   {
38885     try {
38886       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
38887     } catch (std::out_of_range& e) {
38888       {
38889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38890       };
38891     } catch (std::exception& e) {
38892       {
38893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38894       };
38895     } catch (Dali::DaliException e) {
38896       {
38897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38898       };
38899     } catch (...) {
38900       {
38901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38902       };
38903     }
38904   }
38905
38906   jresult = result;
38907   return jresult;
38908 }
38909
38910
38911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
38912   unsigned int jresult ;
38913   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38914   Dali::KeyEvent *arg2 = 0 ;
38915   bool result;
38916
38917   arg1 = (Dali::CustomActorImpl *)jarg1;
38918   arg2 = (Dali::KeyEvent *)jarg2;
38919   if (!arg2) {
38920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
38921     return 0;
38922   }
38923   {
38924     try {
38925       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
38926     } catch (std::out_of_range& e) {
38927       {
38928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38929       };
38930     } catch (std::exception& e) {
38931       {
38932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38933       };
38934     } catch (Dali::DaliException e) {
38935       {
38936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38937       };
38938     } catch (...) {
38939       {
38940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38941       };
38942     }
38943   }
38944
38945   jresult = result;
38946   return jresult;
38947 }
38948
38949
38950 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
38951   unsigned int jresult ;
38952   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38953   Dali::WheelEvent *arg2 = 0 ;
38954   bool result;
38955
38956   arg1 = (Dali::CustomActorImpl *)jarg1;
38957   arg2 = (Dali::WheelEvent *)jarg2;
38958   if (!arg2) {
38959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
38960     return 0;
38961   }
38962   {
38963     try {
38964       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
38965     } catch (std::out_of_range& e) {
38966       {
38967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38968       };
38969     } catch (std::exception& e) {
38970       {
38971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38972       };
38973     } catch (Dali::DaliException e) {
38974       {
38975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38976       };
38977     } catch (...) {
38978       {
38979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38980       };
38981     }
38982   }
38983
38984   jresult = result;
38985   return jresult;
38986 }
38987
38988
38989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
38990   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38991   Dali::Vector2 *arg2 = 0 ;
38992   Dali::RelayoutContainer *arg3 = 0 ;
38993
38994   arg1 = (Dali::CustomActorImpl *)jarg1;
38995   arg2 = (Dali::Vector2 *)jarg2;
38996   if (!arg2) {
38997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38998     return ;
38999   }
39000   arg3 = (Dali::RelayoutContainer *)jarg3;
39001   if (!arg3) {
39002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39003     return ;
39004   }
39005   {
39006     try {
39007       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39008     } catch (std::out_of_range& e) {
39009       {
39010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39011       };
39012     } catch (std::exception& e) {
39013       {
39014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39015       };
39016     } catch (Dali::DaliException e) {
39017       {
39018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39019       };
39020     } catch (...) {
39021       {
39022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39023       };
39024     }
39025   }
39026
39027 }
39028
39029
39030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39031   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39032   Dali::ResizePolicy::Type arg2 ;
39033   Dali::Dimension::Type arg3 ;
39034
39035   arg1 = (Dali::CustomActorImpl *)jarg1;
39036   arg2 = (Dali::ResizePolicy::Type)jarg2;
39037   arg3 = (Dali::Dimension::Type)jarg3;
39038   {
39039     try {
39040       (arg1)->OnSetResizePolicy(arg2,arg3);
39041     } catch (std::out_of_range& e) {
39042       {
39043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39044       };
39045     } catch (std::exception& e) {
39046       {
39047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39048       };
39049     } catch (Dali::DaliException e) {
39050       {
39051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39052       };
39053     } catch (...) {
39054       {
39055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39056       };
39057     }
39058   }
39059
39060 }
39061
39062
39063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39064   void * jresult ;
39065   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39066   Dali::Vector3 result;
39067
39068   arg1 = (Dali::CustomActorImpl *)jarg1;
39069   {
39070     try {
39071       result = (arg1)->GetNaturalSize();
39072     } catch (std::out_of_range& e) {
39073       {
39074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39075       };
39076     } catch (std::exception& e) {
39077       {
39078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39079       };
39080     } catch (Dali::DaliException e) {
39081       {
39082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39083       };
39084     } catch (...) {
39085       {
39086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39087       };
39088     }
39089   }
39090
39091   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39092   return jresult;
39093 }
39094
39095
39096 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39097   float jresult ;
39098   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39099   Dali::Actor *arg2 = 0 ;
39100   Dali::Dimension::Type arg3 ;
39101   float result;
39102
39103   arg1 = (Dali::CustomActorImpl *)jarg1;
39104   arg2 = (Dali::Actor *)jarg2;
39105   if (!arg2) {
39106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39107     return 0;
39108   }
39109   arg3 = (Dali::Dimension::Type)jarg3;
39110   {
39111     try {
39112       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39113     } catch (std::out_of_range& e) {
39114       {
39115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39116       };
39117     } catch (std::exception& e) {
39118       {
39119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39120       };
39121     } catch (Dali::DaliException e) {
39122       {
39123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39124       };
39125     } catch (...) {
39126       {
39127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39128       };
39129     }
39130   }
39131
39132   jresult = result;
39133   return jresult;
39134 }
39135
39136
39137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39138   float jresult ;
39139   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39140   float arg2 ;
39141   float result;
39142
39143   arg1 = (Dali::CustomActorImpl *)jarg1;
39144   arg2 = (float)jarg2;
39145   {
39146     try {
39147       result = (float)(arg1)->GetHeightForWidth(arg2);
39148     } catch (std::out_of_range& e) {
39149       {
39150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39151       };
39152     } catch (std::exception& e) {
39153       {
39154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39155       };
39156     } catch (Dali::DaliException e) {
39157       {
39158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39159       };
39160     } catch (...) {
39161       {
39162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39163       };
39164     }
39165   }
39166
39167   jresult = result;
39168   return jresult;
39169 }
39170
39171
39172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39173   float jresult ;
39174   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39175   float arg2 ;
39176   float result;
39177
39178   arg1 = (Dali::CustomActorImpl *)jarg1;
39179   arg2 = (float)jarg2;
39180   {
39181     try {
39182       result = (float)(arg1)->GetWidthForHeight(arg2);
39183     } catch (std::out_of_range& e) {
39184       {
39185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39186       };
39187     } catch (std::exception& e) {
39188       {
39189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39190       };
39191     } catch (Dali::DaliException e) {
39192       {
39193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39194       };
39195     } catch (...) {
39196       {
39197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39198       };
39199     }
39200   }
39201
39202   jresult = result;
39203   return jresult;
39204 }
39205
39206
39207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39208   unsigned int jresult ;
39209   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39210   Dali::Dimension::Type arg2 ;
39211   bool result;
39212
39213   arg1 = (Dali::CustomActorImpl *)jarg1;
39214   arg2 = (Dali::Dimension::Type)jarg2;
39215   {
39216     try {
39217       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39218     } catch (std::out_of_range& e) {
39219       {
39220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39221       };
39222     } catch (std::exception& e) {
39223       {
39224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39225       };
39226     } catch (Dali::DaliException e) {
39227       {
39228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39229       };
39230     } catch (...) {
39231       {
39232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39233       };
39234     }
39235   }
39236
39237   jresult = result;
39238   return jresult;
39239 }
39240
39241
39242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39243   unsigned int jresult ;
39244   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39245   bool result;
39246
39247   arg1 = (Dali::CustomActorImpl *)jarg1;
39248   {
39249     try {
39250       result = (bool)(arg1)->RelayoutDependentOnChildren();
39251     } catch (std::out_of_range& e) {
39252       {
39253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39254       };
39255     } catch (std::exception& e) {
39256       {
39257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39258       };
39259     } catch (Dali::DaliException e) {
39260       {
39261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39262       };
39263     } catch (...) {
39264       {
39265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39266       };
39267     }
39268   }
39269
39270   jresult = result;
39271   return jresult;
39272 }
39273
39274
39275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39276   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39277   Dali::Dimension::Type arg2 ;
39278
39279   arg1 = (Dali::CustomActorImpl *)jarg1;
39280   arg2 = (Dali::Dimension::Type)jarg2;
39281   {
39282     try {
39283       (arg1)->OnCalculateRelayoutSize(arg2);
39284     } catch (std::out_of_range& e) {
39285       {
39286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39287       };
39288     } catch (std::exception& e) {
39289       {
39290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39291       };
39292     } catch (Dali::DaliException e) {
39293       {
39294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39295       };
39296     } catch (...) {
39297       {
39298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39299       };
39300     }
39301   }
39302
39303 }
39304
39305
39306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39307   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39308   float arg2 ;
39309   Dali::Dimension::Type arg3 ;
39310
39311   arg1 = (Dali::CustomActorImpl *)jarg1;
39312   arg2 = (float)jarg2;
39313   arg3 = (Dali::Dimension::Type)jarg3;
39314   {
39315     try {
39316       (arg1)->OnLayoutNegotiated(arg2,arg3);
39317     } catch (std::out_of_range& e) {
39318       {
39319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39320       };
39321     } catch (std::exception& e) {
39322       {
39323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39324       };
39325     } catch (Dali::DaliException e) {
39326       {
39327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39328       };
39329     } catch (...) {
39330       {
39331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39332       };
39333     }
39334   }
39335
39336 }
39337
39338
39339 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39340   unsigned int jresult ;
39341   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39342   bool result;
39343
39344   arg1 = (Dali::CustomActorImpl *)jarg1;
39345   {
39346     try {
39347       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39348     } catch (std::out_of_range& e) {
39349       {
39350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39351       };
39352     } catch (std::exception& e) {
39353       {
39354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39355       };
39356     } catch (Dali::DaliException e) {
39357       {
39358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39359       };
39360     } catch (...) {
39361       {
39362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39363       };
39364     }
39365   }
39366
39367   jresult = result;
39368   return jresult;
39369 }
39370
39371
39372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39373   unsigned int jresult ;
39374   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39375   bool result;
39376
39377   arg1 = (Dali::CustomActorImpl *)jarg1;
39378   {
39379     try {
39380       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39381     } catch (std::out_of_range& e) {
39382       {
39383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39384       };
39385     } catch (std::exception& e) {
39386       {
39387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39388       };
39389     } catch (Dali::DaliException e) {
39390       {
39391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39392       };
39393     } catch (...) {
39394       {
39395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39396       };
39397     }
39398   }
39399
39400   jresult = result;
39401   return jresult;
39402 }
39403
39404
39405 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39406   unsigned int jresult ;
39407   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39408   bool result;
39409
39410   arg1 = (Dali::CustomActorImpl *)jarg1;
39411   {
39412     try {
39413       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39414     } catch (std::out_of_range& e) {
39415       {
39416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39417       };
39418     } catch (std::exception& e) {
39419       {
39420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39421       };
39422     } catch (Dali::DaliException e) {
39423       {
39424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39425       };
39426     } catch (...) {
39427       {
39428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39429       };
39430     }
39431   }
39432
39433   jresult = result;
39434   return jresult;
39435 }
39436
39437
39438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
39439   unsigned int jresult ;
39440   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39441   bool result;
39442
39443   arg1 = (Dali::CustomActorImpl *)jarg1;
39444   {
39445     try {
39446       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
39447     } catch (std::out_of_range& e) {
39448       {
39449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39450       };
39451     } catch (std::exception& e) {
39452       {
39453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39454       };
39455     } catch (Dali::DaliException e) {
39456       {
39457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39458       };
39459     } catch (...) {
39460       {
39461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39462       };
39463     }
39464   }
39465
39466   jresult = result;
39467   return jresult;
39468 }
39469
39470
39471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
39472   void * jresult ;
39473   Dali::CustomActor *result = 0 ;
39474
39475   {
39476     try {
39477       result = (Dali::CustomActor *)new Dali::CustomActor();
39478     } catch (std::out_of_range& e) {
39479       {
39480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39481       };
39482     } catch (std::exception& e) {
39483       {
39484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39485       };
39486     } catch (Dali::DaliException e) {
39487       {
39488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39489       };
39490     } catch (...) {
39491       {
39492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39493       };
39494     }
39495   }
39496
39497   jresult = (void *)result;
39498   return jresult;
39499 }
39500
39501
39502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
39503   void * jresult ;
39504   Dali::BaseHandle arg1 ;
39505   Dali::BaseHandle *argp1 ;
39506   Dali::CustomActor result;
39507
39508   argp1 = (Dali::BaseHandle *)jarg1;
39509   if (!argp1) {
39510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39511     return 0;
39512   }
39513   arg1 = *argp1;
39514   {
39515     try {
39516       result = Dali::CustomActor::DownCast(arg1);
39517     } catch (std::out_of_range& e) {
39518       {
39519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39520       };
39521     } catch (std::exception& e) {
39522       {
39523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39524       };
39525     } catch (Dali::DaliException e) {
39526       {
39527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39528       };
39529     } catch (...) {
39530       {
39531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39532       };
39533     }
39534   }
39535
39536   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39537   return jresult;
39538 }
39539
39540
39541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
39542   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39543
39544   arg1 = (Dali::CustomActor *)jarg1;
39545   {
39546     try {
39547       delete arg1;
39548     } catch (std::out_of_range& e) {
39549       {
39550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39551       };
39552     } catch (std::exception& e) {
39553       {
39554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39555       };
39556     } catch (Dali::DaliException e) {
39557       {
39558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39559       };
39560     } catch (...) {
39561       {
39562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39563       };
39564     }
39565   }
39566
39567 }
39568
39569
39570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
39571   void * jresult ;
39572   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39573   Dali::CustomActorImpl *result = 0 ;
39574
39575   arg1 = (Dali::CustomActor *)jarg1;
39576   {
39577     try {
39578       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
39579     } catch (std::out_of_range& e) {
39580       {
39581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39582       };
39583     } catch (std::exception& e) {
39584       {
39585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39586       };
39587     } catch (Dali::DaliException e) {
39588       {
39589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39590       };
39591     } catch (...) {
39592       {
39593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39594       };
39595     }
39596   }
39597
39598   jresult = (void *)result;
39599   return jresult;
39600 }
39601
39602
39603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
39604   void * jresult ;
39605   Dali::CustomActorImpl *arg1 = 0 ;
39606   Dali::CustomActor *result = 0 ;
39607
39608   arg1 = (Dali::CustomActorImpl *)jarg1;
39609   if (!arg1) {
39610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
39611     return 0;
39612   }
39613   {
39614     try {
39615       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
39616     } catch (std::out_of_range& e) {
39617       {
39618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39619       };
39620     } catch (std::exception& e) {
39621       {
39622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39623       };
39624     } catch (Dali::DaliException e) {
39625       {
39626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39627       };
39628     } catch (...) {
39629       {
39630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39631       };
39632     }
39633   }
39634
39635   jresult = (void *)result;
39636   return jresult;
39637 }
39638
39639
39640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
39641   void * jresult ;
39642   Dali::CustomActor *arg1 = 0 ;
39643   Dali::CustomActor *result = 0 ;
39644
39645   arg1 = (Dali::CustomActor *)jarg1;
39646   if (!arg1) {
39647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39648     return 0;
39649   }
39650   {
39651     try {
39652       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
39653     } catch (std::out_of_range& e) {
39654       {
39655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39656       };
39657     } catch (std::exception& e) {
39658       {
39659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39660       };
39661     } catch (Dali::DaliException e) {
39662       {
39663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39664       };
39665     } catch (...) {
39666       {
39667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39668       };
39669     }
39670   }
39671
39672   jresult = (void *)result;
39673   return jresult;
39674 }
39675
39676
39677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
39678   void * jresult ;
39679   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39680   Dali::CustomActor *arg2 = 0 ;
39681   Dali::CustomActor *result = 0 ;
39682
39683   arg1 = (Dali::CustomActor *)jarg1;
39684   arg2 = (Dali::CustomActor *)jarg2;
39685   if (!arg2) {
39686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39687     return 0;
39688   }
39689   {
39690     try {
39691       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
39692     } catch (std::out_of_range& e) {
39693       {
39694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39695       };
39696     } catch (std::exception& e) {
39697       {
39698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39699       };
39700     } catch (Dali::DaliException e) {
39701       {
39702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39703       };
39704     } catch (...) {
39705       {
39706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39707       };
39708     }
39709   }
39710
39711   jresult = (void *)result;
39712   return jresult;
39713 }
39714
39715
39716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
39717   int jresult ;
39718   int result;
39719
39720   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
39721   jresult = (int)result;
39722   return jresult;
39723 }
39724
39725
39726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
39727   int jresult ;
39728   int result;
39729
39730   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
39731   jresult = (int)result;
39732   return jresult;
39733 }
39734
39735
39736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
39737   int jresult ;
39738   int result;
39739
39740   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
39741   jresult = (int)result;
39742   return jresult;
39743 }
39744
39745
39746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
39747   int jresult ;
39748   int result;
39749
39750   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
39751   jresult = (int)result;
39752   return jresult;
39753 }
39754
39755
39756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
39757   int jresult ;
39758   int result;
39759
39760   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
39761   jresult = (int)result;
39762   return jresult;
39763 }
39764
39765
39766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
39767   int jresult ;
39768   int result;
39769
39770   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
39771   jresult = (int)result;
39772   return jresult;
39773 }
39774
39775
39776 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
39777   int jresult ;
39778   int result;
39779
39780   result = (int)Dali::PanGestureDetector::Property::PANNING;
39781   jresult = (int)result;
39782   return jresult;
39783 }
39784
39785
39786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
39787   void * jresult ;
39788   Dali::PanGestureDetector::Property *result = 0 ;
39789
39790   {
39791     try {
39792       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
39793     } catch (std::out_of_range& e) {
39794       {
39795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39796       };
39797     } catch (std::exception& e) {
39798       {
39799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39800       };
39801     } catch (Dali::DaliException e) {
39802       {
39803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39804       };
39805     } catch (...) {
39806       {
39807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39808       };
39809     }
39810   }
39811
39812   jresult = (void *)result;
39813   return jresult;
39814 }
39815
39816
39817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
39818   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
39819
39820   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
39821   {
39822     try {
39823       delete arg1;
39824     } catch (std::out_of_range& e) {
39825       {
39826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39827       };
39828     } catch (std::exception& e) {
39829       {
39830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39831       };
39832     } catch (Dali::DaliException e) {
39833       {
39834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39835       };
39836     } catch (...) {
39837       {
39838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39839       };
39840     }
39841   }
39842
39843 }
39844
39845
39846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
39847   void * jresult ;
39848   Dali::Radian *result = 0 ;
39849
39850   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
39851   jresult = (void *)result;
39852   return jresult;
39853 }
39854
39855
39856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
39857   void * jresult ;
39858   Dali::Radian *result = 0 ;
39859
39860   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
39861   jresult = (void *)result;
39862   return jresult;
39863 }
39864
39865
39866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
39867   void * jresult ;
39868   Dali::Radian *result = 0 ;
39869
39870   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
39871   jresult = (void *)result;
39872   return jresult;
39873 }
39874
39875
39876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
39877   void * jresult ;
39878   Dali::Radian *result = 0 ;
39879
39880   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
39881   jresult = (void *)result;
39882   return jresult;
39883 }
39884
39885
39886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
39887   void * jresult ;
39888   Dali::Radian *result = 0 ;
39889
39890   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
39891   jresult = (void *)result;
39892   return jresult;
39893 }
39894
39895
39896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
39897   void * jresult ;
39898   Dali::Radian *result = 0 ;
39899
39900   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
39901   jresult = (void *)result;
39902   return jresult;
39903 }
39904
39905
39906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
39907   void * jresult ;
39908   Dali::Radian *result = 0 ;
39909
39910   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
39911   jresult = (void *)result;
39912   return jresult;
39913 }
39914
39915
39916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
39917   void * jresult ;
39918   Dali::PanGestureDetector *result = 0 ;
39919
39920   {
39921     try {
39922       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
39923     } catch (std::out_of_range& e) {
39924       {
39925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39926       };
39927     } catch (std::exception& e) {
39928       {
39929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39930       };
39931     } catch (Dali::DaliException e) {
39932       {
39933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39934       };
39935     } catch (...) {
39936       {
39937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39938       };
39939     }
39940   }
39941
39942   jresult = (void *)result;
39943   return jresult;
39944 }
39945
39946
39947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
39948   void * jresult ;
39949   Dali::PanGestureDetector result;
39950
39951   {
39952     try {
39953       result = Dali::PanGestureDetector::New();
39954     } catch (std::out_of_range& e) {
39955       {
39956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39957       };
39958     } catch (std::exception& e) {
39959       {
39960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39961       };
39962     } catch (Dali::DaliException e) {
39963       {
39964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39965       };
39966     } catch (...) {
39967       {
39968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39969       };
39970     }
39971   }
39972
39973   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
39974   return jresult;
39975 }
39976
39977
39978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
39979   void * jresult ;
39980   Dali::BaseHandle arg1 ;
39981   Dali::BaseHandle *argp1 ;
39982   Dali::PanGestureDetector result;
39983
39984   argp1 = (Dali::BaseHandle *)jarg1;
39985   if (!argp1) {
39986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39987     return 0;
39988   }
39989   arg1 = *argp1;
39990   {
39991     try {
39992       result = Dali::PanGestureDetector::DownCast(arg1);
39993     } catch (std::out_of_range& e) {
39994       {
39995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39996       };
39997     } catch (std::exception& e) {
39998       {
39999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40000       };
40001     } catch (Dali::DaliException e) {
40002       {
40003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40004       };
40005     } catch (...) {
40006       {
40007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40008       };
40009     }
40010   }
40011
40012   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40013   return jresult;
40014 }
40015
40016
40017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40018   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40019
40020   arg1 = (Dali::PanGestureDetector *)jarg1;
40021   {
40022     try {
40023       delete arg1;
40024     } catch (std::out_of_range& e) {
40025       {
40026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40027       };
40028     } catch (std::exception& e) {
40029       {
40030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40031       };
40032     } catch (Dali::DaliException e) {
40033       {
40034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40035       };
40036     } catch (...) {
40037       {
40038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40039       };
40040     }
40041   }
40042
40043 }
40044
40045
40046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40047   void * jresult ;
40048   Dali::PanGestureDetector *arg1 = 0 ;
40049   Dali::PanGestureDetector *result = 0 ;
40050
40051   arg1 = (Dali::PanGestureDetector *)jarg1;
40052   if (!arg1) {
40053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40054     return 0;
40055   }
40056   {
40057     try {
40058       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40059     } catch (std::out_of_range& e) {
40060       {
40061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40062       };
40063     } catch (std::exception& e) {
40064       {
40065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40066       };
40067     } catch (Dali::DaliException e) {
40068       {
40069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40070       };
40071     } catch (...) {
40072       {
40073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40074       };
40075     }
40076   }
40077
40078   jresult = (void *)result;
40079   return jresult;
40080 }
40081
40082
40083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40084   void * jresult ;
40085   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40086   Dali::PanGestureDetector *arg2 = 0 ;
40087   Dali::PanGestureDetector *result = 0 ;
40088
40089   arg1 = (Dali::PanGestureDetector *)jarg1;
40090   arg2 = (Dali::PanGestureDetector *)jarg2;
40091   if (!arg2) {
40092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40093     return 0;
40094   }
40095   {
40096     try {
40097       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40098     } catch (std::out_of_range& e) {
40099       {
40100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40101       };
40102     } catch (std::exception& e) {
40103       {
40104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40105       };
40106     } catch (Dali::DaliException e) {
40107       {
40108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40109       };
40110     } catch (...) {
40111       {
40112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40113       };
40114     }
40115   }
40116
40117   jresult = (void *)result;
40118   return jresult;
40119 }
40120
40121
40122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40123   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40124   unsigned int arg2 ;
40125
40126   arg1 = (Dali::PanGestureDetector *)jarg1;
40127   arg2 = (unsigned int)jarg2;
40128   {
40129     try {
40130       (arg1)->SetMinimumTouchesRequired(arg2);
40131     } catch (std::out_of_range& e) {
40132       {
40133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40134       };
40135     } catch (std::exception& e) {
40136       {
40137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40138       };
40139     } catch (Dali::DaliException e) {
40140       {
40141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40142       };
40143     } catch (...) {
40144       {
40145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40146       };
40147     }
40148   }
40149
40150 }
40151
40152
40153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40154   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40155   unsigned int arg2 ;
40156
40157   arg1 = (Dali::PanGestureDetector *)jarg1;
40158   arg2 = (unsigned int)jarg2;
40159   {
40160     try {
40161       (arg1)->SetMaximumTouchesRequired(arg2);
40162     } catch (std::out_of_range& e) {
40163       {
40164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40165       };
40166     } catch (std::exception& e) {
40167       {
40168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40169       };
40170     } catch (Dali::DaliException e) {
40171       {
40172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40173       };
40174     } catch (...) {
40175       {
40176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40177       };
40178     }
40179   }
40180
40181 }
40182
40183
40184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40185   unsigned int jresult ;
40186   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40187   unsigned int result;
40188
40189   arg1 = (Dali::PanGestureDetector *)jarg1;
40190   {
40191     try {
40192       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40193     } catch (std::out_of_range& e) {
40194       {
40195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40196       };
40197     } catch (std::exception& e) {
40198       {
40199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40200       };
40201     } catch (Dali::DaliException e) {
40202       {
40203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40204       };
40205     } catch (...) {
40206       {
40207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40208       };
40209     }
40210   }
40211
40212   jresult = result;
40213   return jresult;
40214 }
40215
40216
40217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40218   unsigned int jresult ;
40219   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40220   unsigned int result;
40221
40222   arg1 = (Dali::PanGestureDetector *)jarg1;
40223   {
40224     try {
40225       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40226     } catch (std::out_of_range& e) {
40227       {
40228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40229       };
40230     } catch (std::exception& e) {
40231       {
40232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40233       };
40234     } catch (Dali::DaliException e) {
40235       {
40236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40237       };
40238     } catch (...) {
40239       {
40240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40241       };
40242     }
40243   }
40244
40245   jresult = result;
40246   return jresult;
40247 }
40248
40249
40250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40251   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40252   Dali::Radian arg2 ;
40253   Dali::Radian arg3 ;
40254   Dali::Radian *argp2 ;
40255   Dali::Radian *argp3 ;
40256
40257   arg1 = (Dali::PanGestureDetector *)jarg1;
40258   argp2 = (Dali::Radian *)jarg2;
40259   if (!argp2) {
40260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40261     return ;
40262   }
40263   arg2 = *argp2;
40264   argp3 = (Dali::Radian *)jarg3;
40265   if (!argp3) {
40266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40267     return ;
40268   }
40269   arg3 = *argp3;
40270   {
40271     try {
40272       (arg1)->AddAngle(arg2,arg3);
40273     } catch (std::out_of_range& e) {
40274       {
40275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40276       };
40277     } catch (std::exception& e) {
40278       {
40279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40280       };
40281     } catch (Dali::DaliException e) {
40282       {
40283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40284       };
40285     } catch (...) {
40286       {
40287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40288       };
40289     }
40290   }
40291
40292 }
40293
40294
40295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40296   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40297   Dali::Radian arg2 ;
40298   Dali::Radian *argp2 ;
40299
40300   arg1 = (Dali::PanGestureDetector *)jarg1;
40301   argp2 = (Dali::Radian *)jarg2;
40302   if (!argp2) {
40303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40304     return ;
40305   }
40306   arg2 = *argp2;
40307   {
40308     try {
40309       (arg1)->AddAngle(arg2);
40310     } catch (std::out_of_range& e) {
40311       {
40312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40313       };
40314     } catch (std::exception& e) {
40315       {
40316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40317       };
40318     } catch (Dali::DaliException e) {
40319       {
40320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40321       };
40322     } catch (...) {
40323       {
40324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40325       };
40326     }
40327   }
40328
40329 }
40330
40331
40332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40333   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40334   Dali::Radian arg2 ;
40335   Dali::Radian arg3 ;
40336   Dali::Radian *argp2 ;
40337   Dali::Radian *argp3 ;
40338
40339   arg1 = (Dali::PanGestureDetector *)jarg1;
40340   argp2 = (Dali::Radian *)jarg2;
40341   if (!argp2) {
40342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40343     return ;
40344   }
40345   arg2 = *argp2;
40346   argp3 = (Dali::Radian *)jarg3;
40347   if (!argp3) {
40348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40349     return ;
40350   }
40351   arg3 = *argp3;
40352   {
40353     try {
40354       (arg1)->AddDirection(arg2,arg3);
40355     } catch (std::out_of_range& e) {
40356       {
40357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40358       };
40359     } catch (std::exception& e) {
40360       {
40361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40362       };
40363     } catch (Dali::DaliException e) {
40364       {
40365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40366       };
40367     } catch (...) {
40368       {
40369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40370       };
40371     }
40372   }
40373
40374 }
40375
40376
40377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40378   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40379   Dali::Radian arg2 ;
40380   Dali::Radian *argp2 ;
40381
40382   arg1 = (Dali::PanGestureDetector *)jarg1;
40383   argp2 = (Dali::Radian *)jarg2;
40384   if (!argp2) {
40385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40386     return ;
40387   }
40388   arg2 = *argp2;
40389   {
40390     try {
40391       (arg1)->AddDirection(arg2);
40392     } catch (std::out_of_range& e) {
40393       {
40394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40395       };
40396     } catch (std::exception& e) {
40397       {
40398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40399       };
40400     } catch (Dali::DaliException e) {
40401       {
40402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40403       };
40404     } catch (...) {
40405       {
40406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40407       };
40408     }
40409   }
40410
40411 }
40412
40413
40414 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40415   unsigned long jresult ;
40416   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40417   size_t result;
40418
40419   arg1 = (Dali::PanGestureDetector *)jarg1;
40420   {
40421     try {
40422       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
40423     } catch (std::out_of_range& e) {
40424       {
40425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40426       };
40427     } catch (std::exception& e) {
40428       {
40429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40430       };
40431     } catch (Dali::DaliException e) {
40432       {
40433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40434       };
40435     } catch (...) {
40436       {
40437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40438       };
40439     }
40440   }
40441
40442   jresult = (unsigned long)result;
40443   return jresult;
40444 }
40445
40446
40447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
40448   void * jresult ;
40449   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40450   size_t arg2 ;
40451   Dali::PanGestureDetector::AngleThresholdPair result;
40452
40453   arg1 = (Dali::PanGestureDetector *)jarg1;
40454   arg2 = (size_t)jarg2;
40455   {
40456     try {
40457       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
40458     } catch (std::out_of_range& e) {
40459       {
40460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40461       };
40462     } catch (std::exception& e) {
40463       {
40464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40465       };
40466     } catch (Dali::DaliException e) {
40467       {
40468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40469       };
40470     } catch (...) {
40471       {
40472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40473       };
40474     }
40475   }
40476
40477   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
40478   return jresult;
40479 }
40480
40481
40482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
40483   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40484
40485   arg1 = (Dali::PanGestureDetector *)jarg1;
40486   {
40487     try {
40488       (arg1)->ClearAngles();
40489     } catch (std::out_of_range& e) {
40490       {
40491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40492       };
40493     } catch (std::exception& e) {
40494       {
40495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40496       };
40497     } catch (Dali::DaliException e) {
40498       {
40499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40500       };
40501     } catch (...) {
40502       {
40503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40504       };
40505     }
40506   }
40507
40508 }
40509
40510
40511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
40512   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40513   Dali::Radian arg2 ;
40514   Dali::Radian *argp2 ;
40515
40516   arg1 = (Dali::PanGestureDetector *)jarg1;
40517   argp2 = (Dali::Radian *)jarg2;
40518   if (!argp2) {
40519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40520     return ;
40521   }
40522   arg2 = *argp2;
40523   {
40524     try {
40525       (arg1)->RemoveAngle(arg2);
40526     } catch (std::out_of_range& e) {
40527       {
40528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40529       };
40530     } catch (std::exception& e) {
40531       {
40532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40533       };
40534     } catch (Dali::DaliException e) {
40535       {
40536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40537       };
40538     } catch (...) {
40539       {
40540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40541       };
40542     }
40543   }
40544
40545 }
40546
40547
40548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
40549   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40550   Dali::Radian arg2 ;
40551   Dali::Radian *argp2 ;
40552
40553   arg1 = (Dali::PanGestureDetector *)jarg1;
40554   argp2 = (Dali::Radian *)jarg2;
40555   if (!argp2) {
40556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40557     return ;
40558   }
40559   arg2 = *argp2;
40560   {
40561     try {
40562       (arg1)->RemoveDirection(arg2);
40563     } catch (std::out_of_range& e) {
40564       {
40565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40566       };
40567     } catch (std::exception& e) {
40568       {
40569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40570       };
40571     } catch (Dali::DaliException e) {
40572       {
40573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40574       };
40575     } catch (...) {
40576       {
40577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40578       };
40579     }
40580   }
40581
40582 }
40583
40584
40585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
40586   void * jresult ;
40587   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40588   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
40589
40590   arg1 = (Dali::PanGestureDetector *)jarg1;
40591   {
40592     try {
40593       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
40594     } catch (std::out_of_range& e) {
40595       {
40596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40597       };
40598     } catch (std::exception& e) {
40599       {
40600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40601       };
40602     } catch (Dali::DaliException e) {
40603       {
40604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40605       };
40606     } catch (...) {
40607       {
40608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40609       };
40610     }
40611   }
40612
40613   jresult = (void *)result;
40614   return jresult;
40615 }
40616
40617
40618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
40619   Dali::PanGesture *arg1 = 0 ;
40620
40621   arg1 = (Dali::PanGesture *)jarg1;
40622   if (!arg1) {
40623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40624     return ;
40625   }
40626   {
40627     try {
40628       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
40629     } catch (std::out_of_range& e) {
40630       {
40631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40632       };
40633     } catch (std::exception& e) {
40634       {
40635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40636       };
40637     } catch (Dali::DaliException e) {
40638       {
40639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40640       };
40641     } catch (...) {
40642       {
40643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40644       };
40645     }
40646   }
40647
40648 }
40649
40650
40651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
40652   void * jresult ;
40653   Dali::PanGesture *result = 0 ;
40654
40655   {
40656     try {
40657       result = (Dali::PanGesture *)new Dali::PanGesture();
40658     } catch (std::out_of_range& e) {
40659       {
40660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40661       };
40662     } catch (std::exception& e) {
40663       {
40664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40665       };
40666     } catch (Dali::DaliException e) {
40667       {
40668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40669       };
40670     } catch (...) {
40671       {
40672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40673       };
40674     }
40675   }
40676
40677   jresult = (void *)result;
40678   return jresult;
40679 }
40680
40681
40682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
40683   void * jresult ;
40684   Dali::Gesture::State arg1 ;
40685   Dali::PanGesture *result = 0 ;
40686
40687   arg1 = (Dali::Gesture::State)jarg1;
40688   {
40689     try {
40690       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
40691     } catch (std::out_of_range& e) {
40692       {
40693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40694       };
40695     } catch (std::exception& e) {
40696       {
40697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40698       };
40699     } catch (Dali::DaliException e) {
40700       {
40701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40702       };
40703     } catch (...) {
40704       {
40705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40706       };
40707     }
40708   }
40709
40710   jresult = (void *)result;
40711   return jresult;
40712 }
40713
40714
40715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
40716   void * jresult ;
40717   Dali::PanGesture *arg1 = 0 ;
40718   Dali::PanGesture *result = 0 ;
40719
40720   arg1 = (Dali::PanGesture *)jarg1;
40721   if (!arg1) {
40722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40723     return 0;
40724   }
40725   {
40726     try {
40727       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
40728     } catch (std::out_of_range& e) {
40729       {
40730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40731       };
40732     } catch (std::exception& e) {
40733       {
40734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40735       };
40736     } catch (Dali::DaliException e) {
40737       {
40738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40739       };
40740     } catch (...) {
40741       {
40742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40743       };
40744     }
40745   }
40746
40747   jresult = (void *)result;
40748   return jresult;
40749 }
40750
40751
40752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
40753   void * jresult ;
40754   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40755   Dali::PanGesture *arg2 = 0 ;
40756   Dali::PanGesture *result = 0 ;
40757
40758   arg1 = (Dali::PanGesture *)jarg1;
40759   arg2 = (Dali::PanGesture *)jarg2;
40760   if (!arg2) {
40761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40762     return 0;
40763   }
40764   {
40765     try {
40766       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
40767     } catch (std::out_of_range& e) {
40768       {
40769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40770       };
40771     } catch (std::exception& e) {
40772       {
40773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40774       };
40775     } catch (Dali::DaliException e) {
40776       {
40777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40778       };
40779     } catch (...) {
40780       {
40781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40782       };
40783     }
40784   }
40785
40786   jresult = (void *)result;
40787   return jresult;
40788 }
40789
40790
40791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
40792   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40793
40794   arg1 = (Dali::PanGesture *)jarg1;
40795   {
40796     try {
40797       delete arg1;
40798     } catch (std::out_of_range& e) {
40799       {
40800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40801       };
40802     } catch (std::exception& e) {
40803       {
40804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40805       };
40806     } catch (Dali::DaliException e) {
40807       {
40808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40809       };
40810     } catch (...) {
40811       {
40812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40813       };
40814     }
40815   }
40816
40817 }
40818
40819
40820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
40821   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40822   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40823
40824   arg1 = (Dali::PanGesture *)jarg1;
40825   arg2 = (Dali::Vector2 *)jarg2;
40826   if (arg1) (arg1)->velocity = *arg2;
40827 }
40828
40829
40830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
40831   void * jresult ;
40832   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40833   Dali::Vector2 *result = 0 ;
40834
40835   arg1 = (Dali::PanGesture *)jarg1;
40836   result = (Dali::Vector2 *)& ((arg1)->velocity);
40837   jresult = (void *)result;
40838   return jresult;
40839 }
40840
40841
40842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
40843   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40844   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40845
40846   arg1 = (Dali::PanGesture *)jarg1;
40847   arg2 = (Dali::Vector2 *)jarg2;
40848   if (arg1) (arg1)->displacement = *arg2;
40849 }
40850
40851
40852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
40853   void * jresult ;
40854   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40855   Dali::Vector2 *result = 0 ;
40856
40857   arg1 = (Dali::PanGesture *)jarg1;
40858   result = (Dali::Vector2 *)& ((arg1)->displacement);
40859   jresult = (void *)result;
40860   return jresult;
40861 }
40862
40863
40864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
40865   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40866   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40867
40868   arg1 = (Dali::PanGesture *)jarg1;
40869   arg2 = (Dali::Vector2 *)jarg2;
40870   if (arg1) (arg1)->position = *arg2;
40871 }
40872
40873
40874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
40875   void * jresult ;
40876   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40877   Dali::Vector2 *result = 0 ;
40878
40879   arg1 = (Dali::PanGesture *)jarg1;
40880   result = (Dali::Vector2 *)& ((arg1)->position);
40881   jresult = (void *)result;
40882   return jresult;
40883 }
40884
40885
40886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
40887   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40888   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40889
40890   arg1 = (Dali::PanGesture *)jarg1;
40891   arg2 = (Dali::Vector2 *)jarg2;
40892   if (arg1) (arg1)->screenVelocity = *arg2;
40893 }
40894
40895
40896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
40897   void * jresult ;
40898   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40899   Dali::Vector2 *result = 0 ;
40900
40901   arg1 = (Dali::PanGesture *)jarg1;
40902   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
40903   jresult = (void *)result;
40904   return jresult;
40905 }
40906
40907
40908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
40909   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40910   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40911
40912   arg1 = (Dali::PanGesture *)jarg1;
40913   arg2 = (Dali::Vector2 *)jarg2;
40914   if (arg1) (arg1)->screenDisplacement = *arg2;
40915 }
40916
40917
40918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
40919   void * jresult ;
40920   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40921   Dali::Vector2 *result = 0 ;
40922
40923   arg1 = (Dali::PanGesture *)jarg1;
40924   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
40925   jresult = (void *)result;
40926   return jresult;
40927 }
40928
40929
40930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
40931   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40932   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40933
40934   arg1 = (Dali::PanGesture *)jarg1;
40935   arg2 = (Dali::Vector2 *)jarg2;
40936   if (arg1) (arg1)->screenPosition = *arg2;
40937 }
40938
40939
40940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
40941   void * jresult ;
40942   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40943   Dali::Vector2 *result = 0 ;
40944
40945   arg1 = (Dali::PanGesture *)jarg1;
40946   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
40947   jresult = (void *)result;
40948   return jresult;
40949 }
40950
40951
40952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
40953   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40954   unsigned int arg2 ;
40955
40956   arg1 = (Dali::PanGesture *)jarg1;
40957   arg2 = (unsigned int)jarg2;
40958   if (arg1) (arg1)->numberOfTouches = arg2;
40959 }
40960
40961
40962 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
40963   unsigned int jresult ;
40964   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40965   unsigned int result;
40966
40967   arg1 = (Dali::PanGesture *)jarg1;
40968   result = (unsigned int) ((arg1)->numberOfTouches);
40969   jresult = result;
40970   return jresult;
40971 }
40972
40973
40974 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
40975   float jresult ;
40976   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40977   float result;
40978
40979   arg1 = (Dali::PanGesture *)jarg1;
40980   {
40981     try {
40982       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
40983     } catch (std::out_of_range& e) {
40984       {
40985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40986       };
40987     } catch (std::exception& e) {
40988       {
40989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40990       };
40991     } catch (Dali::DaliException e) {
40992       {
40993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40994       };
40995     } catch (...) {
40996       {
40997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40998       };
40999     }
41000   }
41001
41002   jresult = result;
41003   return jresult;
41004 }
41005
41006
41007 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41008   float jresult ;
41009   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41010   float result;
41011
41012   arg1 = (Dali::PanGesture *)jarg1;
41013   {
41014     try {
41015       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41016     } catch (std::out_of_range& e) {
41017       {
41018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41019       };
41020     } catch (std::exception& e) {
41021       {
41022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41023       };
41024     } catch (Dali::DaliException e) {
41025       {
41026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41027       };
41028     } catch (...) {
41029       {
41030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41031       };
41032     }
41033   }
41034
41035   jresult = result;
41036   return jresult;
41037 }
41038
41039
41040 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41041   float jresult ;
41042   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41043   float result;
41044
41045   arg1 = (Dali::PanGesture *)jarg1;
41046   {
41047     try {
41048       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41049     } catch (std::out_of_range& e) {
41050       {
41051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41052       };
41053     } catch (std::exception& e) {
41054       {
41055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41056       };
41057     } catch (Dali::DaliException e) {
41058       {
41059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41060       };
41061     } catch (...) {
41062       {
41063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41064       };
41065     }
41066   }
41067
41068   jresult = result;
41069   return jresult;
41070 }
41071
41072
41073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41074   float jresult ;
41075   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41076   float result;
41077
41078   arg1 = (Dali::PanGesture *)jarg1;
41079   {
41080     try {
41081       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41082     } catch (std::out_of_range& e) {
41083       {
41084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41085       };
41086     } catch (std::exception& e) {
41087       {
41088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41089       };
41090     } catch (Dali::DaliException e) {
41091       {
41092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41093       };
41094     } catch (...) {
41095       {
41096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41097       };
41098     }
41099   }
41100
41101   jresult = result;
41102   return jresult;
41103 }
41104
41105
41106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41107   void * jresult ;
41108   Dali::PinchGestureDetector *result = 0 ;
41109
41110   {
41111     try {
41112       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41113     } catch (std::out_of_range& e) {
41114       {
41115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41116       };
41117     } catch (std::exception& e) {
41118       {
41119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41120       };
41121     } catch (Dali::DaliException e) {
41122       {
41123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41124       };
41125     } catch (...) {
41126       {
41127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41128       };
41129     }
41130   }
41131
41132   jresult = (void *)result;
41133   return jresult;
41134 }
41135
41136
41137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41138   void * jresult ;
41139   Dali::PinchGestureDetector result;
41140
41141   {
41142     try {
41143       result = Dali::PinchGestureDetector::New();
41144     } catch (std::out_of_range& e) {
41145       {
41146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41147       };
41148     } catch (std::exception& e) {
41149       {
41150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41151       };
41152     } catch (Dali::DaliException e) {
41153       {
41154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41155       };
41156     } catch (...) {
41157       {
41158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41159       };
41160     }
41161   }
41162
41163   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41164   return jresult;
41165 }
41166
41167
41168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41169   void * jresult ;
41170   Dali::BaseHandle arg1 ;
41171   Dali::BaseHandle *argp1 ;
41172   Dali::PinchGestureDetector result;
41173
41174   argp1 = (Dali::BaseHandle *)jarg1;
41175   if (!argp1) {
41176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41177     return 0;
41178   }
41179   arg1 = *argp1;
41180   {
41181     try {
41182       result = Dali::PinchGestureDetector::DownCast(arg1);
41183     } catch (std::out_of_range& e) {
41184       {
41185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41186       };
41187     } catch (std::exception& e) {
41188       {
41189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41190       };
41191     } catch (Dali::DaliException e) {
41192       {
41193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41194       };
41195     } catch (...) {
41196       {
41197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41198       };
41199     }
41200   }
41201
41202   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41203   return jresult;
41204 }
41205
41206
41207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41208   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41209
41210   arg1 = (Dali::PinchGestureDetector *)jarg1;
41211   {
41212     try {
41213       delete arg1;
41214     } catch (std::out_of_range& e) {
41215       {
41216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41217       };
41218     } catch (std::exception& e) {
41219       {
41220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41221       };
41222     } catch (Dali::DaliException e) {
41223       {
41224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41225       };
41226     } catch (...) {
41227       {
41228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41229       };
41230     }
41231   }
41232
41233 }
41234
41235
41236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41237   void * jresult ;
41238   Dali::PinchGestureDetector *arg1 = 0 ;
41239   Dali::PinchGestureDetector *result = 0 ;
41240
41241   arg1 = (Dali::PinchGestureDetector *)jarg1;
41242   if (!arg1) {
41243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41244     return 0;
41245   }
41246   {
41247     try {
41248       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41249     } catch (std::out_of_range& e) {
41250       {
41251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41252       };
41253     } catch (std::exception& e) {
41254       {
41255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41256       };
41257     } catch (Dali::DaliException e) {
41258       {
41259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41260       };
41261     } catch (...) {
41262       {
41263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41264       };
41265     }
41266   }
41267
41268   jresult = (void *)result;
41269   return jresult;
41270 }
41271
41272
41273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41274   void * jresult ;
41275   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41276   Dali::PinchGestureDetector *arg2 = 0 ;
41277   Dali::PinchGestureDetector *result = 0 ;
41278
41279   arg1 = (Dali::PinchGestureDetector *)jarg1;
41280   arg2 = (Dali::PinchGestureDetector *)jarg2;
41281   if (!arg2) {
41282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41283     return 0;
41284   }
41285   {
41286     try {
41287       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41288     } catch (std::out_of_range& e) {
41289       {
41290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41291       };
41292     } catch (std::exception& e) {
41293       {
41294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41295       };
41296     } catch (Dali::DaliException e) {
41297       {
41298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41299       };
41300     } catch (...) {
41301       {
41302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41303       };
41304     }
41305   }
41306
41307   jresult = (void *)result;
41308   return jresult;
41309 }
41310
41311
41312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41313   void * jresult ;
41314   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41315   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41316
41317   arg1 = (Dali::PinchGestureDetector *)jarg1;
41318   {
41319     try {
41320       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41321     } catch (std::out_of_range& e) {
41322       {
41323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41324       };
41325     } catch (std::exception& e) {
41326       {
41327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41328       };
41329     } catch (Dali::DaliException e) {
41330       {
41331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41332       };
41333     } catch (...) {
41334       {
41335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41336       };
41337     }
41338   }
41339
41340   jresult = (void *)result;
41341   return jresult;
41342 }
41343
41344
41345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41346   void * jresult ;
41347   Dali::Gesture::State arg1 ;
41348   Dali::PinchGesture *result = 0 ;
41349
41350   arg1 = (Dali::Gesture::State)jarg1;
41351   {
41352     try {
41353       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41354     } catch (std::out_of_range& e) {
41355       {
41356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41357       };
41358     } catch (std::exception& e) {
41359       {
41360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41361       };
41362     } catch (Dali::DaliException e) {
41363       {
41364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41365       };
41366     } catch (...) {
41367       {
41368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41369       };
41370     }
41371   }
41372
41373   jresult = (void *)result;
41374   return jresult;
41375 }
41376
41377
41378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41379   void * jresult ;
41380   Dali::PinchGesture *arg1 = 0 ;
41381   Dali::PinchGesture *result = 0 ;
41382
41383   arg1 = (Dali::PinchGesture *)jarg1;
41384   if (!arg1) {
41385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41386     return 0;
41387   }
41388   {
41389     try {
41390       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41391     } catch (std::out_of_range& e) {
41392       {
41393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41394       };
41395     } catch (std::exception& e) {
41396       {
41397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41398       };
41399     } catch (Dali::DaliException e) {
41400       {
41401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41402       };
41403     } catch (...) {
41404       {
41405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41406       };
41407     }
41408   }
41409
41410   jresult = (void *)result;
41411   return jresult;
41412 }
41413
41414
41415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
41416   void * jresult ;
41417   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41418   Dali::PinchGesture *arg2 = 0 ;
41419   Dali::PinchGesture *result = 0 ;
41420
41421   arg1 = (Dali::PinchGesture *)jarg1;
41422   arg2 = (Dali::PinchGesture *)jarg2;
41423   if (!arg2) {
41424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41425     return 0;
41426   }
41427   {
41428     try {
41429       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
41430     } catch (std::out_of_range& e) {
41431       {
41432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41433       };
41434     } catch (std::exception& e) {
41435       {
41436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41437       };
41438     } catch (Dali::DaliException e) {
41439       {
41440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41441       };
41442     } catch (...) {
41443       {
41444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41445       };
41446     }
41447   }
41448
41449   jresult = (void *)result;
41450   return jresult;
41451 }
41452
41453
41454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
41455   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41456
41457   arg1 = (Dali::PinchGesture *)jarg1;
41458   {
41459     try {
41460       delete arg1;
41461     } catch (std::out_of_range& e) {
41462       {
41463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41464       };
41465     } catch (std::exception& e) {
41466       {
41467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41468       };
41469     } catch (Dali::DaliException e) {
41470       {
41471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41472       };
41473     } catch (...) {
41474       {
41475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41476       };
41477     }
41478   }
41479
41480 }
41481
41482
41483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
41484   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41485   float arg2 ;
41486
41487   arg1 = (Dali::PinchGesture *)jarg1;
41488   arg2 = (float)jarg2;
41489   if (arg1) (arg1)->scale = arg2;
41490 }
41491
41492
41493 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
41494   float jresult ;
41495   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41496   float result;
41497
41498   arg1 = (Dali::PinchGesture *)jarg1;
41499   result = (float) ((arg1)->scale);
41500   jresult = result;
41501   return jresult;
41502 }
41503
41504
41505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
41506   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41507   float arg2 ;
41508
41509   arg1 = (Dali::PinchGesture *)jarg1;
41510   arg2 = (float)jarg2;
41511   if (arg1) (arg1)->speed = arg2;
41512 }
41513
41514
41515 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
41516   float jresult ;
41517   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41518   float result;
41519
41520   arg1 = (Dali::PinchGesture *)jarg1;
41521   result = (float) ((arg1)->speed);
41522   jresult = result;
41523   return jresult;
41524 }
41525
41526
41527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
41528   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41529   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41530
41531   arg1 = (Dali::PinchGesture *)jarg1;
41532   arg2 = (Dali::Vector2 *)jarg2;
41533   if (arg1) (arg1)->screenCenterPoint = *arg2;
41534 }
41535
41536
41537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
41538   void * jresult ;
41539   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41540   Dali::Vector2 *result = 0 ;
41541
41542   arg1 = (Dali::PinchGesture *)jarg1;
41543   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
41544   jresult = (void *)result;
41545   return jresult;
41546 }
41547
41548
41549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
41550   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41551   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41552
41553   arg1 = (Dali::PinchGesture *)jarg1;
41554   arg2 = (Dali::Vector2 *)jarg2;
41555   if (arg1) (arg1)->localCenterPoint = *arg2;
41556 }
41557
41558
41559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
41560   void * jresult ;
41561   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41562   Dali::Vector2 *result = 0 ;
41563
41564   arg1 = (Dali::PinchGesture *)jarg1;
41565   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
41566   jresult = (void *)result;
41567   return jresult;
41568 }
41569
41570
41571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
41572   void * jresult ;
41573   Dali::TapGestureDetector *result = 0 ;
41574
41575   {
41576     try {
41577       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
41578     } catch (std::out_of_range& e) {
41579       {
41580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41581       };
41582     } catch (std::exception& e) {
41583       {
41584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41585       };
41586     } catch (Dali::DaliException e) {
41587       {
41588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41589       };
41590     } catch (...) {
41591       {
41592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41593       };
41594     }
41595   }
41596
41597   jresult = (void *)result;
41598   return jresult;
41599 }
41600
41601
41602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
41603   void * jresult ;
41604   Dali::TapGestureDetector result;
41605
41606   {
41607     try {
41608       result = Dali::TapGestureDetector::New();
41609     } catch (std::out_of_range& e) {
41610       {
41611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41612       };
41613     } catch (std::exception& e) {
41614       {
41615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41616       };
41617     } catch (Dali::DaliException e) {
41618       {
41619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41620       };
41621     } catch (...) {
41622       {
41623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41624       };
41625     }
41626   }
41627
41628   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41629   return jresult;
41630 }
41631
41632
41633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
41634   void * jresult ;
41635   unsigned int arg1 ;
41636   Dali::TapGestureDetector result;
41637
41638   arg1 = (unsigned int)jarg1;
41639   {
41640     try {
41641       result = Dali::TapGestureDetector::New(arg1);
41642     } catch (std::out_of_range& e) {
41643       {
41644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41645       };
41646     } catch (std::exception& e) {
41647       {
41648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41649       };
41650     } catch (Dali::DaliException e) {
41651       {
41652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41653       };
41654     } catch (...) {
41655       {
41656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41657       };
41658     }
41659   }
41660
41661   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41662   return jresult;
41663 }
41664
41665
41666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
41667   void * jresult ;
41668   Dali::BaseHandle arg1 ;
41669   Dali::BaseHandle *argp1 ;
41670   Dali::TapGestureDetector result;
41671
41672   argp1 = (Dali::BaseHandle *)jarg1;
41673   if (!argp1) {
41674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41675     return 0;
41676   }
41677   arg1 = *argp1;
41678   {
41679     try {
41680       result = Dali::TapGestureDetector::DownCast(arg1);
41681     } catch (std::out_of_range& e) {
41682       {
41683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41684       };
41685     } catch (std::exception& e) {
41686       {
41687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41688       };
41689     } catch (Dali::DaliException e) {
41690       {
41691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41692       };
41693     } catch (...) {
41694       {
41695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41696       };
41697     }
41698   }
41699
41700   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41701   return jresult;
41702 }
41703
41704
41705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
41706   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41707
41708   arg1 = (Dali::TapGestureDetector *)jarg1;
41709   {
41710     try {
41711       delete arg1;
41712     } catch (std::out_of_range& e) {
41713       {
41714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41715       };
41716     } catch (std::exception& e) {
41717       {
41718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41719       };
41720     } catch (Dali::DaliException e) {
41721       {
41722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41723       };
41724     } catch (...) {
41725       {
41726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41727       };
41728     }
41729   }
41730
41731 }
41732
41733
41734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
41735   void * jresult ;
41736   Dali::TapGestureDetector *arg1 = 0 ;
41737   Dali::TapGestureDetector *result = 0 ;
41738
41739   arg1 = (Dali::TapGestureDetector *)jarg1;
41740   if (!arg1) {
41741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41742     return 0;
41743   }
41744   {
41745     try {
41746       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
41747     } catch (std::out_of_range& e) {
41748       {
41749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41750       };
41751     } catch (std::exception& e) {
41752       {
41753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41754       };
41755     } catch (Dali::DaliException e) {
41756       {
41757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41758       };
41759     } catch (...) {
41760       {
41761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41762       };
41763     }
41764   }
41765
41766   jresult = (void *)result;
41767   return jresult;
41768 }
41769
41770
41771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
41772   void * jresult ;
41773   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41774   Dali::TapGestureDetector *arg2 = 0 ;
41775   Dali::TapGestureDetector *result = 0 ;
41776
41777   arg1 = (Dali::TapGestureDetector *)jarg1;
41778   arg2 = (Dali::TapGestureDetector *)jarg2;
41779   if (!arg2) {
41780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41781     return 0;
41782   }
41783   {
41784     try {
41785       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
41786     } catch (std::out_of_range& e) {
41787       {
41788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41789       };
41790     } catch (std::exception& e) {
41791       {
41792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41793       };
41794     } catch (Dali::DaliException e) {
41795       {
41796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41797       };
41798     } catch (...) {
41799       {
41800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41801       };
41802     }
41803   }
41804
41805   jresult = (void *)result;
41806   return jresult;
41807 }
41808
41809
41810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
41811   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41812   unsigned int arg2 ;
41813
41814   arg1 = (Dali::TapGestureDetector *)jarg1;
41815   arg2 = (unsigned int)jarg2;
41816   {
41817     try {
41818       (arg1)->SetMinimumTapsRequired(arg2);
41819     } catch (std::out_of_range& e) {
41820       {
41821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41822       };
41823     } catch (std::exception& e) {
41824       {
41825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41826       };
41827     } catch (Dali::DaliException e) {
41828       {
41829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41830       };
41831     } catch (...) {
41832       {
41833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41834       };
41835     }
41836   }
41837
41838 }
41839
41840
41841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
41842   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41843   unsigned int arg2 ;
41844
41845   arg1 = (Dali::TapGestureDetector *)jarg1;
41846   arg2 = (unsigned int)jarg2;
41847   {
41848     try {
41849       (arg1)->SetMaximumTapsRequired(arg2);
41850     } catch (std::out_of_range& e) {
41851       {
41852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41853       };
41854     } catch (std::exception& e) {
41855       {
41856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41857       };
41858     } catch (Dali::DaliException e) {
41859       {
41860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41861       };
41862     } catch (...) {
41863       {
41864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41865       };
41866     }
41867   }
41868
41869 }
41870
41871
41872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
41873   unsigned int jresult ;
41874   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41875   unsigned int result;
41876
41877   arg1 = (Dali::TapGestureDetector *)jarg1;
41878   {
41879     try {
41880       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
41881     } catch (std::out_of_range& e) {
41882       {
41883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41884       };
41885     } catch (std::exception& e) {
41886       {
41887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41888       };
41889     } catch (Dali::DaliException e) {
41890       {
41891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41892       };
41893     } catch (...) {
41894       {
41895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41896       };
41897     }
41898   }
41899
41900   jresult = result;
41901   return jresult;
41902 }
41903
41904
41905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
41906   unsigned int jresult ;
41907   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41908   unsigned int result;
41909
41910   arg1 = (Dali::TapGestureDetector *)jarg1;
41911   {
41912     try {
41913       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
41914     } catch (std::out_of_range& e) {
41915       {
41916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41917       };
41918     } catch (std::exception& e) {
41919       {
41920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41921       };
41922     } catch (Dali::DaliException e) {
41923       {
41924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41925       };
41926     } catch (...) {
41927       {
41928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41929       };
41930     }
41931   }
41932
41933   jresult = result;
41934   return jresult;
41935 }
41936
41937
41938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
41939   void * jresult ;
41940   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41941   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
41942
41943   arg1 = (Dali::TapGestureDetector *)jarg1;
41944   {
41945     try {
41946       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41947     } catch (std::out_of_range& e) {
41948       {
41949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41950       };
41951     } catch (std::exception& e) {
41952       {
41953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41954       };
41955     } catch (Dali::DaliException e) {
41956       {
41957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41958       };
41959     } catch (...) {
41960       {
41961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41962       };
41963     }
41964   }
41965
41966   jresult = (void *)result;
41967   return jresult;
41968 }
41969
41970
41971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
41972   void * jresult ;
41973   Dali::TapGesture *result = 0 ;
41974
41975   {
41976     try {
41977       result = (Dali::TapGesture *)new Dali::TapGesture();
41978     } catch (std::out_of_range& e) {
41979       {
41980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41981       };
41982     } catch (std::exception& e) {
41983       {
41984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41985       };
41986     } catch (Dali::DaliException e) {
41987       {
41988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41989       };
41990     } catch (...) {
41991       {
41992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41993       };
41994     }
41995   }
41996
41997   jresult = (void *)result;
41998   return jresult;
41999 }
42000
42001
42002 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42003   void * jresult ;
42004   Dali::TapGesture *arg1 = 0 ;
42005   Dali::TapGesture *result = 0 ;
42006
42007   arg1 = (Dali::TapGesture *)jarg1;
42008   if (!arg1) {
42009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42010     return 0;
42011   }
42012   {
42013     try {
42014       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42015     } catch (std::out_of_range& e) {
42016       {
42017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42018       };
42019     } catch (std::exception& e) {
42020       {
42021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42022       };
42023     } catch (Dali::DaliException e) {
42024       {
42025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42026       };
42027     } catch (...) {
42028       {
42029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42030       };
42031     }
42032   }
42033
42034   jresult = (void *)result;
42035   return jresult;
42036 }
42037
42038
42039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42040   void * jresult ;
42041   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42042   Dali::TapGesture *arg2 = 0 ;
42043   Dali::TapGesture *result = 0 ;
42044
42045   arg1 = (Dali::TapGesture *)jarg1;
42046   arg2 = (Dali::TapGesture *)jarg2;
42047   if (!arg2) {
42048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42049     return 0;
42050   }
42051   {
42052     try {
42053       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42054     } catch (std::out_of_range& e) {
42055       {
42056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42057       };
42058     } catch (std::exception& e) {
42059       {
42060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42061       };
42062     } catch (Dali::DaliException e) {
42063       {
42064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42065       };
42066     } catch (...) {
42067       {
42068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42069       };
42070     }
42071   }
42072
42073   jresult = (void *)result;
42074   return jresult;
42075 }
42076
42077
42078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42079   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42080
42081   arg1 = (Dali::TapGesture *)jarg1;
42082   {
42083     try {
42084       delete arg1;
42085     } catch (std::out_of_range& e) {
42086       {
42087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42088       };
42089     } catch (std::exception& e) {
42090       {
42091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42092       };
42093     } catch (Dali::DaliException e) {
42094       {
42095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42096       };
42097     } catch (...) {
42098       {
42099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42100       };
42101     }
42102   }
42103
42104 }
42105
42106
42107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42108   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42109   unsigned int arg2 ;
42110
42111   arg1 = (Dali::TapGesture *)jarg1;
42112   arg2 = (unsigned int)jarg2;
42113   if (arg1) (arg1)->numberOfTaps = arg2;
42114 }
42115
42116
42117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42118   unsigned int jresult ;
42119   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42120   unsigned int result;
42121
42122   arg1 = (Dali::TapGesture *)jarg1;
42123   result = (unsigned int) ((arg1)->numberOfTaps);
42124   jresult = result;
42125   return jresult;
42126 }
42127
42128
42129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42130   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42131   unsigned int arg2 ;
42132
42133   arg1 = (Dali::TapGesture *)jarg1;
42134   arg2 = (unsigned int)jarg2;
42135   if (arg1) (arg1)->numberOfTouches = arg2;
42136 }
42137
42138
42139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42140   unsigned int jresult ;
42141   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42142   unsigned int result;
42143
42144   arg1 = (Dali::TapGesture *)jarg1;
42145   result = (unsigned int) ((arg1)->numberOfTouches);
42146   jresult = result;
42147   return jresult;
42148 }
42149
42150
42151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42152   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42153   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42154
42155   arg1 = (Dali::TapGesture *)jarg1;
42156   arg2 = (Dali::Vector2 *)jarg2;
42157   if (arg1) (arg1)->screenPoint = *arg2;
42158 }
42159
42160
42161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42162   void * jresult ;
42163   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42164   Dali::Vector2 *result = 0 ;
42165
42166   arg1 = (Dali::TapGesture *)jarg1;
42167   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42168   jresult = (void *)result;
42169   return jresult;
42170 }
42171
42172
42173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42174   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42175   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42176
42177   arg1 = (Dali::TapGesture *)jarg1;
42178   arg2 = (Dali::Vector2 *)jarg2;
42179   if (arg1) (arg1)->localPoint = *arg2;
42180 }
42181
42182
42183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42184   void * jresult ;
42185   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42186   Dali::Vector2 *result = 0 ;
42187
42188   arg1 = (Dali::TapGesture *)jarg1;
42189   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42190   jresult = (void *)result;
42191   return jresult;
42192 }
42193
42194
42195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42196   void * jresult ;
42197   Dali::AlphaFunction *result = 0 ;
42198
42199   {
42200     try {
42201       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42202     } catch (std::out_of_range& e) {
42203       {
42204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42205       };
42206     } catch (std::exception& e) {
42207       {
42208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42209       };
42210     } catch (Dali::DaliException e) {
42211       {
42212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42213       };
42214     } catch (...) {
42215       {
42216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42217       };
42218     }
42219   }
42220
42221   jresult = (void *)result;
42222   return jresult;
42223 }
42224
42225
42226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42227   void * jresult ;
42228   Dali::AlphaFunction::BuiltinFunction arg1 ;
42229   Dali::AlphaFunction *result = 0 ;
42230
42231   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42232   {
42233     try {
42234       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42235     } catch (std::out_of_range& e) {
42236       {
42237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42238       };
42239     } catch (std::exception& e) {
42240       {
42241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42242       };
42243     } catch (Dali::DaliException e) {
42244       {
42245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42246       };
42247     } catch (...) {
42248       {
42249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42250       };
42251     }
42252   }
42253
42254   jresult = (void *)result;
42255   return jresult;
42256 }
42257
42258
42259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42260   void * jresult ;
42261   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42262   Dali::AlphaFunction *result = 0 ;
42263
42264   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42265   {
42266     try {
42267       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42268     } catch (std::out_of_range& e) {
42269       {
42270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42271       };
42272     } catch (std::exception& e) {
42273       {
42274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42275       };
42276     } catch (Dali::DaliException e) {
42277       {
42278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42279       };
42280     } catch (...) {
42281       {
42282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42283       };
42284     }
42285   }
42286
42287   jresult = (void *)result;
42288   return jresult;
42289 }
42290
42291
42292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42293   void * jresult ;
42294   Dali::Vector2 *arg1 = 0 ;
42295   Dali::Vector2 *arg2 = 0 ;
42296   Dali::AlphaFunction *result = 0 ;
42297
42298   arg1 = (Dali::Vector2 *)jarg1;
42299   if (!arg1) {
42300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42301     return 0;
42302   }
42303   arg2 = (Dali::Vector2 *)jarg2;
42304   if (!arg2) {
42305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42306     return 0;
42307   }
42308   {
42309     try {
42310       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42311     } catch (std::out_of_range& e) {
42312       {
42313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42314       };
42315     } catch (std::exception& e) {
42316       {
42317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42318       };
42319     } catch (Dali::DaliException e) {
42320       {
42321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42322       };
42323     } catch (...) {
42324       {
42325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42326       };
42327     }
42328   }
42329
42330   jresult = (void *)result;
42331   return jresult;
42332 }
42333
42334
42335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42336   void * jresult ;
42337   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42338   Dali::Vector4 result;
42339
42340   arg1 = (Dali::AlphaFunction *)jarg1;
42341   {
42342     try {
42343       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42344     } catch (std::out_of_range& e) {
42345       {
42346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42347       };
42348     } catch (std::exception& e) {
42349       {
42350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42351       };
42352     } catch (Dali::DaliException e) {
42353       {
42354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42355       };
42356     } catch (...) {
42357       {
42358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42359       };
42360     }
42361   }
42362
42363   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42364   return jresult;
42365 }
42366
42367
42368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42369   void * jresult ;
42370   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42371   Dali::AlphaFunctionPrototype result;
42372
42373   arg1 = (Dali::AlphaFunction *)jarg1;
42374   {
42375     try {
42376       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42377     } catch (std::out_of_range& e) {
42378       {
42379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42380       };
42381     } catch (std::exception& e) {
42382       {
42383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42384       };
42385     } catch (Dali::DaliException e) {
42386       {
42387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42388       };
42389     } catch (...) {
42390       {
42391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42392       };
42393     }
42394   }
42395
42396   jresult = (void *)result;
42397   return jresult;
42398 }
42399
42400
42401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42402   int jresult ;
42403   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42404   Dali::AlphaFunction::BuiltinFunction result;
42405
42406   arg1 = (Dali::AlphaFunction *)jarg1;
42407   {
42408     try {
42409       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
42410     } catch (std::out_of_range& e) {
42411       {
42412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42413       };
42414     } catch (std::exception& e) {
42415       {
42416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42417       };
42418     } catch (Dali::DaliException e) {
42419       {
42420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42421       };
42422     } catch (...) {
42423       {
42424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42425       };
42426     }
42427   }
42428
42429   jresult = (int)result;
42430   return jresult;
42431 }
42432
42433
42434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
42435   int jresult ;
42436   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42437   Dali::AlphaFunction::Mode result;
42438
42439   arg1 = (Dali::AlphaFunction *)jarg1;
42440   {
42441     try {
42442       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
42443     } catch (std::out_of_range& e) {
42444       {
42445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42446       };
42447     } catch (std::exception& e) {
42448       {
42449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42450       };
42451     } catch (Dali::DaliException e) {
42452       {
42453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42454       };
42455     } catch (...) {
42456       {
42457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42458       };
42459     }
42460   }
42461
42462   jresult = (int)result;
42463   return jresult;
42464 }
42465
42466
42467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
42468   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42469
42470   arg1 = (Dali::AlphaFunction *)jarg1;
42471   {
42472     try {
42473       delete arg1;
42474     } catch (std::out_of_range& e) {
42475       {
42476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42477       };
42478     } catch (std::exception& e) {
42479       {
42480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42481       };
42482     } catch (Dali::DaliException e) {
42483       {
42484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42485       };
42486     } catch (...) {
42487       {
42488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42489       };
42490     }
42491   }
42492
42493 }
42494
42495
42496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
42497   void * jresult ;
42498   Dali::KeyFrames result;
42499
42500   {
42501     try {
42502       result = Dali::KeyFrames::New();
42503     } catch (std::out_of_range& e) {
42504       {
42505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42506       };
42507     } catch (std::exception& e) {
42508       {
42509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42510       };
42511     } catch (Dali::DaliException e) {
42512       {
42513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42514       };
42515     } catch (...) {
42516       {
42517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42518       };
42519     }
42520   }
42521
42522   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42523   return jresult;
42524 }
42525
42526
42527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
42528   void * jresult ;
42529   Dali::BaseHandle arg1 ;
42530   Dali::BaseHandle *argp1 ;
42531   Dali::KeyFrames result;
42532
42533   argp1 = (Dali::BaseHandle *)jarg1;
42534   if (!argp1) {
42535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42536     return 0;
42537   }
42538   arg1 = *argp1;
42539   {
42540     try {
42541       result = Dali::KeyFrames::DownCast(arg1);
42542     } catch (std::out_of_range& e) {
42543       {
42544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42545       };
42546     } catch (std::exception& e) {
42547       {
42548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42549       };
42550     } catch (Dali::DaliException e) {
42551       {
42552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42553       };
42554     } catch (...) {
42555       {
42556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42557       };
42558     }
42559   }
42560
42561   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42562   return jresult;
42563 }
42564
42565
42566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
42567   void * jresult ;
42568   Dali::KeyFrames *result = 0 ;
42569
42570   {
42571     try {
42572       result = (Dali::KeyFrames *)new Dali::KeyFrames();
42573     } catch (std::out_of_range& e) {
42574       {
42575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42576       };
42577     } catch (std::exception& e) {
42578       {
42579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42580       };
42581     } catch (Dali::DaliException e) {
42582       {
42583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42584       };
42585     } catch (...) {
42586       {
42587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42588       };
42589     }
42590   }
42591
42592   jresult = (void *)result;
42593   return jresult;
42594 }
42595
42596
42597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
42598   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42599
42600   arg1 = (Dali::KeyFrames *)jarg1;
42601   {
42602     try {
42603       delete arg1;
42604     } catch (std::out_of_range& e) {
42605       {
42606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42607       };
42608     } catch (std::exception& e) {
42609       {
42610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42611       };
42612     } catch (Dali::DaliException e) {
42613       {
42614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42615       };
42616     } catch (...) {
42617       {
42618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42619       };
42620     }
42621   }
42622
42623 }
42624
42625
42626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
42627   void * jresult ;
42628   Dali::KeyFrames *arg1 = 0 ;
42629   Dali::KeyFrames *result = 0 ;
42630
42631   arg1 = (Dali::KeyFrames *)jarg1;
42632   if (!arg1) {
42633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42634     return 0;
42635   }
42636   {
42637     try {
42638       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
42639     } catch (std::out_of_range& e) {
42640       {
42641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42642       };
42643     } catch (std::exception& e) {
42644       {
42645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42646       };
42647     } catch (Dali::DaliException e) {
42648       {
42649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42650       };
42651     } catch (...) {
42652       {
42653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42654       };
42655     }
42656   }
42657
42658   jresult = (void *)result;
42659   return jresult;
42660 }
42661
42662
42663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
42664   void * jresult ;
42665   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42666   Dali::KeyFrames *arg2 = 0 ;
42667   Dali::KeyFrames *result = 0 ;
42668
42669   arg1 = (Dali::KeyFrames *)jarg1;
42670   arg2 = (Dali::KeyFrames *)jarg2;
42671   if (!arg2) {
42672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42673     return 0;
42674   }
42675   {
42676     try {
42677       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
42678     } catch (std::out_of_range& e) {
42679       {
42680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42681       };
42682     } catch (std::exception& e) {
42683       {
42684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42685       };
42686     } catch (Dali::DaliException e) {
42687       {
42688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42689       };
42690     } catch (...) {
42691       {
42692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42693       };
42694     }
42695   }
42696
42697   jresult = (void *)result;
42698   return jresult;
42699 }
42700
42701
42702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
42703   int jresult ;
42704   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42705   Dali::Property::Type result;
42706
42707   arg1 = (Dali::KeyFrames *)jarg1;
42708   {
42709     try {
42710       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
42711     } catch (std::out_of_range& e) {
42712       {
42713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42714       };
42715     } catch (std::exception& e) {
42716       {
42717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42718       };
42719     } catch (Dali::DaliException e) {
42720       {
42721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42722       };
42723     } catch (...) {
42724       {
42725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42726       };
42727     }
42728   }
42729
42730   jresult = (int)result;
42731   return jresult;
42732 }
42733
42734
42735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
42736   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42737   float arg2 ;
42738   Dali::Property::Value arg3 ;
42739   Dali::Property::Value *argp3 ;
42740
42741   arg1 = (Dali::KeyFrames *)jarg1;
42742   arg2 = (float)jarg2;
42743   argp3 = (Dali::Property::Value *)jarg3;
42744   if (!argp3) {
42745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42746     return ;
42747   }
42748   arg3 = *argp3;
42749   {
42750     try {
42751       (arg1)->Add(arg2,arg3);
42752     } catch (std::out_of_range& e) {
42753       {
42754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42755       };
42756     } catch (std::exception& e) {
42757       {
42758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42759       };
42760     } catch (Dali::DaliException e) {
42761       {
42762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42763       };
42764     } catch (...) {
42765       {
42766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42767       };
42768     }
42769   }
42770
42771 }
42772
42773
42774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
42775   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42776   float arg2 ;
42777   Dali::Property::Value arg3 ;
42778   Dali::AlphaFunction arg4 ;
42779   Dali::Property::Value *argp3 ;
42780   Dali::AlphaFunction *argp4 ;
42781
42782   arg1 = (Dali::KeyFrames *)jarg1;
42783   arg2 = (float)jarg2;
42784   argp3 = (Dali::Property::Value *)jarg3;
42785   if (!argp3) {
42786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42787     return ;
42788   }
42789   arg3 = *argp3;
42790   argp4 = (Dali::AlphaFunction *)jarg4;
42791   if (!argp4) {
42792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
42793     return ;
42794   }
42795   arg4 = *argp4;
42796   {
42797     try {
42798       (arg1)->Add(arg2,arg3,arg4);
42799     } catch (std::out_of_range& e) {
42800       {
42801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42802       };
42803     } catch (std::exception& e) {
42804       {
42805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42806       };
42807     } catch (Dali::DaliException e) {
42808       {
42809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42810       };
42811     } catch (...) {
42812       {
42813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42814       };
42815     }
42816   }
42817
42818 }
42819
42820
42821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
42822   int jresult ;
42823   int result;
42824
42825   result = (int)Dali::Path::Property::POINTS;
42826   jresult = (int)result;
42827   return jresult;
42828 }
42829
42830
42831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
42832   int jresult ;
42833   int result;
42834
42835   result = (int)Dali::Path::Property::CONTROL_POINTS;
42836   jresult = (int)result;
42837   return jresult;
42838 }
42839
42840
42841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
42842   void * jresult ;
42843   Dali::Path::Property *result = 0 ;
42844
42845   {
42846     try {
42847       result = (Dali::Path::Property *)new Dali::Path::Property();
42848     } catch (std::out_of_range& e) {
42849       {
42850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42851       };
42852     } catch (std::exception& e) {
42853       {
42854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42855       };
42856     } catch (Dali::DaliException e) {
42857       {
42858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42859       };
42860     } catch (...) {
42861       {
42862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42863       };
42864     }
42865   }
42866
42867   jresult = (void *)result;
42868   return jresult;
42869 }
42870
42871
42872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
42873   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
42874
42875   arg1 = (Dali::Path::Property *)jarg1;
42876   {
42877     try {
42878       delete arg1;
42879     } catch (std::out_of_range& e) {
42880       {
42881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42882       };
42883     } catch (std::exception& e) {
42884       {
42885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42886       };
42887     } catch (Dali::DaliException e) {
42888       {
42889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42890       };
42891     } catch (...) {
42892       {
42893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42894       };
42895     }
42896   }
42897
42898 }
42899
42900
42901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
42902   void * jresult ;
42903   Dali::Path result;
42904
42905   {
42906     try {
42907       result = Dali::Path::New();
42908     } catch (std::out_of_range& e) {
42909       {
42910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42911       };
42912     } catch (std::exception& e) {
42913       {
42914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42915       };
42916     } catch (Dali::DaliException e) {
42917       {
42918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42919       };
42920     } catch (...) {
42921       {
42922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42923       };
42924     }
42925   }
42926
42927   jresult = new Dali::Path((const Dali::Path &)result);
42928   return jresult;
42929 }
42930
42931
42932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
42933   void * jresult ;
42934   Dali::BaseHandle arg1 ;
42935   Dali::BaseHandle *argp1 ;
42936   Dali::Path result;
42937
42938   argp1 = (Dali::BaseHandle *)jarg1;
42939   if (!argp1) {
42940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42941     return 0;
42942   }
42943   arg1 = *argp1;
42944   {
42945     try {
42946       result = Dali::Path::DownCast(arg1);
42947     } catch (std::out_of_range& e) {
42948       {
42949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42950       };
42951     } catch (std::exception& e) {
42952       {
42953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42954       };
42955     } catch (Dali::DaliException e) {
42956       {
42957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42958       };
42959     } catch (...) {
42960       {
42961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42962       };
42963     }
42964   }
42965
42966   jresult = new Dali::Path((const Dali::Path &)result);
42967   return jresult;
42968 }
42969
42970
42971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
42972   void * jresult ;
42973   Dali::Path *result = 0 ;
42974
42975   {
42976     try {
42977       result = (Dali::Path *)new Dali::Path();
42978     } catch (std::out_of_range& e) {
42979       {
42980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42981       };
42982     } catch (std::exception& e) {
42983       {
42984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42985       };
42986     } catch (Dali::DaliException e) {
42987       {
42988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42989       };
42990     } catch (...) {
42991       {
42992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42993       };
42994     }
42995   }
42996
42997   jresult = (void *)result;
42998   return jresult;
42999 }
43000
43001
43002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43003   Dali::Path *arg1 = (Dali::Path *) 0 ;
43004
43005   arg1 = (Dali::Path *)jarg1;
43006   {
43007     try {
43008       delete arg1;
43009     } catch (std::out_of_range& e) {
43010       {
43011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43012       };
43013     } catch (std::exception& e) {
43014       {
43015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43016       };
43017     } catch (Dali::DaliException e) {
43018       {
43019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43020       };
43021     } catch (...) {
43022       {
43023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43024       };
43025     }
43026   }
43027
43028 }
43029
43030
43031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43032   void * jresult ;
43033   Dali::Path *arg1 = 0 ;
43034   Dali::Path *result = 0 ;
43035
43036   arg1 = (Dali::Path *)jarg1;
43037   if (!arg1) {
43038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43039     return 0;
43040   }
43041   {
43042     try {
43043       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43044     } catch (std::out_of_range& e) {
43045       {
43046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43047       };
43048     } catch (std::exception& e) {
43049       {
43050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43051       };
43052     } catch (Dali::DaliException e) {
43053       {
43054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43055       };
43056     } catch (...) {
43057       {
43058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43059       };
43060     }
43061   }
43062
43063   jresult = (void *)result;
43064   return jresult;
43065 }
43066
43067
43068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43069   void * jresult ;
43070   Dali::Path *arg1 = (Dali::Path *) 0 ;
43071   Dali::Path *arg2 = 0 ;
43072   Dali::Path *result = 0 ;
43073
43074   arg1 = (Dali::Path *)jarg1;
43075   arg2 = (Dali::Path *)jarg2;
43076   if (!arg2) {
43077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43078     return 0;
43079   }
43080   {
43081     try {
43082       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43083     } catch (std::out_of_range& e) {
43084       {
43085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43086       };
43087     } catch (std::exception& e) {
43088       {
43089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43090       };
43091     } catch (Dali::DaliException e) {
43092       {
43093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43094       };
43095     } catch (...) {
43096       {
43097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43098       };
43099     }
43100   }
43101
43102   jresult = (void *)result;
43103   return jresult;
43104 }
43105
43106
43107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43108   Dali::Path *arg1 = (Dali::Path *) 0 ;
43109   Dali::Vector3 *arg2 = 0 ;
43110
43111   arg1 = (Dali::Path *)jarg1;
43112   arg2 = (Dali::Vector3 *)jarg2;
43113   if (!arg2) {
43114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43115     return ;
43116   }
43117   {
43118     try {
43119       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43120     } catch (std::out_of_range& e) {
43121       {
43122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43123       };
43124     } catch (std::exception& e) {
43125       {
43126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43127       };
43128     } catch (Dali::DaliException e) {
43129       {
43130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43131       };
43132     } catch (...) {
43133       {
43134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43135       };
43136     }
43137   }
43138
43139 }
43140
43141
43142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43143   Dali::Path *arg1 = (Dali::Path *) 0 ;
43144   Dali::Vector3 *arg2 = 0 ;
43145
43146   arg1 = (Dali::Path *)jarg1;
43147   arg2 = (Dali::Vector3 *)jarg2;
43148   if (!arg2) {
43149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43150     return ;
43151   }
43152   {
43153     try {
43154       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43155     } catch (std::out_of_range& e) {
43156       {
43157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43158       };
43159     } catch (std::exception& e) {
43160       {
43161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43162       };
43163     } catch (Dali::DaliException e) {
43164       {
43165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43166       };
43167     } catch (...) {
43168       {
43169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43170       };
43171     }
43172   }
43173
43174 }
43175
43176
43177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43178   Dali::Path *arg1 = (Dali::Path *) 0 ;
43179   float arg2 ;
43180
43181   arg1 = (Dali::Path *)jarg1;
43182   arg2 = (float)jarg2;
43183   {
43184     try {
43185       (arg1)->GenerateControlPoints(arg2);
43186     } catch (std::out_of_range& e) {
43187       {
43188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43189       };
43190     } catch (std::exception& e) {
43191       {
43192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43193       };
43194     } catch (Dali::DaliException e) {
43195       {
43196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43197       };
43198     } catch (...) {
43199       {
43200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43201       };
43202     }
43203   }
43204
43205 }
43206
43207
43208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43209   Dali::Path *arg1 = (Dali::Path *) 0 ;
43210   float arg2 ;
43211   Dali::Vector3 *arg3 = 0 ;
43212   Dali::Vector3 *arg4 = 0 ;
43213
43214   arg1 = (Dali::Path *)jarg1;
43215   arg2 = (float)jarg2;
43216   arg3 = (Dali::Vector3 *)jarg3;
43217   if (!arg3) {
43218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43219     return ;
43220   }
43221   arg4 = (Dali::Vector3 *)jarg4;
43222   if (!arg4) {
43223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43224     return ;
43225   }
43226   {
43227     try {
43228       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43229     } catch (std::out_of_range& e) {
43230       {
43231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43232       };
43233     } catch (std::exception& e) {
43234       {
43235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43236       };
43237     } catch (Dali::DaliException e) {
43238       {
43239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43240       };
43241     } catch (...) {
43242       {
43243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43244       };
43245     }
43246   }
43247
43248 }
43249
43250
43251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43252   void * jresult ;
43253   Dali::Path *arg1 = (Dali::Path *) 0 ;
43254   size_t arg2 ;
43255   Dali::Vector3 *result = 0 ;
43256
43257   arg1 = (Dali::Path *)jarg1;
43258   arg2 = (size_t)jarg2;
43259   {
43260     try {
43261       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43262     } catch (std::out_of_range& e) {
43263       {
43264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43265       };
43266     } catch (std::exception& e) {
43267       {
43268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43269       };
43270     } catch (Dali::DaliException e) {
43271       {
43272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43273       };
43274     } catch (...) {
43275       {
43276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43277       };
43278     }
43279   }
43280
43281   jresult = (void *)result;
43282   return jresult;
43283 }
43284
43285
43286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43287   void * jresult ;
43288   Dali::Path *arg1 = (Dali::Path *) 0 ;
43289   size_t arg2 ;
43290   Dali::Vector3 *result = 0 ;
43291
43292   arg1 = (Dali::Path *)jarg1;
43293   arg2 = (size_t)jarg2;
43294   {
43295     try {
43296       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43297     } catch (std::out_of_range& e) {
43298       {
43299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43300       };
43301     } catch (std::exception& e) {
43302       {
43303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43304       };
43305     } catch (Dali::DaliException e) {
43306       {
43307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43308       };
43309     } catch (...) {
43310       {
43311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43312       };
43313     }
43314   }
43315
43316   jresult = (void *)result;
43317   return jresult;
43318 }
43319
43320
43321 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43322   unsigned long jresult ;
43323   Dali::Path *arg1 = (Dali::Path *) 0 ;
43324   size_t result;
43325
43326   arg1 = (Dali::Path *)jarg1;
43327   {
43328     try {
43329       result = ((Dali::Path const *)arg1)->GetPointCount();
43330     } catch (std::out_of_range& e) {
43331       {
43332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43333       };
43334     } catch (std::exception& e) {
43335       {
43336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43337       };
43338     } catch (Dali::DaliException e) {
43339       {
43340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43341       };
43342     } catch (...) {
43343       {
43344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43345       };
43346     }
43347   }
43348
43349   jresult = (unsigned long)result;
43350   return jresult;
43351 }
43352
43353
43354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43355   void * jresult ;
43356   float arg1 ;
43357   Dali::TimePeriod *result = 0 ;
43358
43359   arg1 = (float)jarg1;
43360   {
43361     try {
43362       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43363     } catch (std::out_of_range& e) {
43364       {
43365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43366       };
43367     } catch (std::exception& e) {
43368       {
43369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43370       };
43371     } catch (Dali::DaliException e) {
43372       {
43373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43374       };
43375     } catch (...) {
43376       {
43377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43378       };
43379     }
43380   }
43381
43382   jresult = (void *)result;
43383   return jresult;
43384 }
43385
43386
43387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43388   void * jresult ;
43389   float arg1 ;
43390   float arg2 ;
43391   Dali::TimePeriod *result = 0 ;
43392
43393   arg1 = (float)jarg1;
43394   arg2 = (float)jarg2;
43395   {
43396     try {
43397       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43398     } catch (std::out_of_range& e) {
43399       {
43400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43401       };
43402     } catch (std::exception& e) {
43403       {
43404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43405       };
43406     } catch (Dali::DaliException e) {
43407       {
43408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43409       };
43410     } catch (...) {
43411       {
43412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43413       };
43414     }
43415   }
43416
43417   jresult = (void *)result;
43418   return jresult;
43419 }
43420
43421
43422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
43423   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43424
43425   arg1 = (Dali::TimePeriod *)jarg1;
43426   {
43427     try {
43428       delete arg1;
43429     } catch (std::out_of_range& e) {
43430       {
43431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43432       };
43433     } catch (std::exception& e) {
43434       {
43435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43436       };
43437     } catch (Dali::DaliException e) {
43438       {
43439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43440       };
43441     } catch (...) {
43442       {
43443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43444       };
43445     }
43446   }
43447
43448 }
43449
43450
43451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
43452   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43453   float arg2 ;
43454
43455   arg1 = (Dali::TimePeriod *)jarg1;
43456   arg2 = (float)jarg2;
43457   if (arg1) (arg1)->delaySeconds = arg2;
43458 }
43459
43460
43461 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
43462   float jresult ;
43463   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43464   float result;
43465
43466   arg1 = (Dali::TimePeriod *)jarg1;
43467   result = (float) ((arg1)->delaySeconds);
43468   jresult = result;
43469   return jresult;
43470 }
43471
43472
43473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
43474   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43475   float arg2 ;
43476
43477   arg1 = (Dali::TimePeriod *)jarg1;
43478   arg2 = (float)jarg2;
43479   if (arg1) (arg1)->durationSeconds = arg2;
43480 }
43481
43482
43483 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
43484   float jresult ;
43485   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43486   float result;
43487
43488   arg1 = (Dali::TimePeriod *)jarg1;
43489   result = (float) ((arg1)->durationSeconds);
43490   jresult = result;
43491   return jresult;
43492 }
43493
43494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
43495   int jresult ;
43496   int result;
43497
43498   result = (int)Dali::LinearConstrainer::Property::VALUE;
43499   jresult = (int)result;
43500   return jresult;
43501 }
43502
43503
43504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
43505   int jresult ;
43506   int result;
43507
43508   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
43509   jresult = (int)result;
43510   return jresult;
43511 }
43512
43513
43514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
43515   void * jresult ;
43516   Dali::LinearConstrainer::Property *result = 0 ;
43517
43518   {
43519     try {
43520       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
43521     } catch (std::out_of_range& e) {
43522       {
43523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43524       };
43525     } catch (std::exception& e) {
43526       {
43527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43528       };
43529     } catch (Dali::DaliException e) {
43530       {
43531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43532       };
43533     } catch (...) {
43534       {
43535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43536       };
43537     }
43538   }
43539
43540   jresult = (void *)result;
43541   return jresult;
43542 }
43543
43544
43545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
43546   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
43547
43548   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
43549   {
43550     try {
43551       delete arg1;
43552     } catch (std::out_of_range& e) {
43553       {
43554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43555       };
43556     } catch (std::exception& e) {
43557       {
43558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43559       };
43560     } catch (Dali::DaliException e) {
43561       {
43562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43563       };
43564     } catch (...) {
43565       {
43566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43567       };
43568     }
43569   }
43570
43571 }
43572
43573
43574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
43575   void * jresult ;
43576   Dali::LinearConstrainer result;
43577
43578   {
43579     try {
43580       result = Dali::LinearConstrainer::New();
43581     } catch (std::out_of_range& e) {
43582       {
43583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43584       };
43585     } catch (std::exception& e) {
43586       {
43587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43588       };
43589     } catch (Dali::DaliException e) {
43590       {
43591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43592       };
43593     } catch (...) {
43594       {
43595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43596       };
43597     }
43598   }
43599
43600   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43601   return jresult;
43602 }
43603
43604
43605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
43606   void * jresult ;
43607   Dali::BaseHandle arg1 ;
43608   Dali::BaseHandle *argp1 ;
43609   Dali::LinearConstrainer result;
43610
43611   argp1 = (Dali::BaseHandle *)jarg1;
43612   if (!argp1) {
43613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43614     return 0;
43615   }
43616   arg1 = *argp1;
43617   {
43618     try {
43619       result = Dali::LinearConstrainer::DownCast(arg1);
43620     } catch (std::out_of_range& e) {
43621       {
43622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43623       };
43624     } catch (std::exception& e) {
43625       {
43626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43627       };
43628     } catch (Dali::DaliException e) {
43629       {
43630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43631       };
43632     } catch (...) {
43633       {
43634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43635       };
43636     }
43637   }
43638
43639   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43640   return jresult;
43641 }
43642
43643
43644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
43645   void * jresult ;
43646   Dali::LinearConstrainer *result = 0 ;
43647
43648   {
43649     try {
43650       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
43651     } catch (std::out_of_range& e) {
43652       {
43653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43654       };
43655     } catch (std::exception& e) {
43656       {
43657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43658       };
43659     } catch (Dali::DaliException e) {
43660       {
43661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43662       };
43663     } catch (...) {
43664       {
43665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43666       };
43667     }
43668   }
43669
43670   jresult = (void *)result;
43671   return jresult;
43672 }
43673
43674
43675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
43676   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43677
43678   arg1 = (Dali::LinearConstrainer *)jarg1;
43679   {
43680     try {
43681       delete arg1;
43682     } catch (std::out_of_range& e) {
43683       {
43684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43685       };
43686     } catch (std::exception& e) {
43687       {
43688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43689       };
43690     } catch (Dali::DaliException e) {
43691       {
43692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43693       };
43694     } catch (...) {
43695       {
43696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43697       };
43698     }
43699   }
43700
43701 }
43702
43703
43704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
43705   void * jresult ;
43706   Dali::LinearConstrainer *arg1 = 0 ;
43707   Dali::LinearConstrainer *result = 0 ;
43708
43709   arg1 = (Dali::LinearConstrainer *)jarg1;
43710   if (!arg1) {
43711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43712     return 0;
43713   }
43714   {
43715     try {
43716       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
43717     } catch (std::out_of_range& e) {
43718       {
43719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43720       };
43721     } catch (std::exception& e) {
43722       {
43723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43724       };
43725     } catch (Dali::DaliException e) {
43726       {
43727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43728       };
43729     } catch (...) {
43730       {
43731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43732       };
43733     }
43734   }
43735
43736   jresult = (void *)result;
43737   return jresult;
43738 }
43739
43740
43741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
43742   void * jresult ;
43743   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43744   Dali::LinearConstrainer *arg2 = 0 ;
43745   Dali::LinearConstrainer *result = 0 ;
43746
43747   arg1 = (Dali::LinearConstrainer *)jarg1;
43748   arg2 = (Dali::LinearConstrainer *)jarg2;
43749   if (!arg2) {
43750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43751     return 0;
43752   }
43753   {
43754     try {
43755       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
43756     } catch (std::out_of_range& e) {
43757       {
43758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43759       };
43760     } catch (std::exception& e) {
43761       {
43762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43763       };
43764     } catch (Dali::DaliException e) {
43765       {
43766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43767       };
43768     } catch (...) {
43769       {
43770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43771       };
43772     }
43773   }
43774
43775   jresult = (void *)result;
43776   return jresult;
43777 }
43778
43779
43780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
43781   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43782   SwigValueWrapper< Dali::Property > arg2 ;
43783   SwigValueWrapper< Dali::Property > arg3 ;
43784   Dali::Vector2 *arg4 = 0 ;
43785   Dali::Vector2 *arg5 = 0 ;
43786   Dali::Property *argp2 ;
43787   Dali::Property *argp3 ;
43788
43789   arg1 = (Dali::LinearConstrainer *)jarg1;
43790   argp2 = (Dali::Property *)jarg2;
43791   if (!argp2) {
43792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43793     return ;
43794   }
43795   arg2 = *argp2;
43796   argp3 = (Dali::Property *)jarg3;
43797   if (!argp3) {
43798     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43799     return ;
43800   }
43801   arg3 = *argp3;
43802   arg4 = (Dali::Vector2 *)jarg4;
43803   if (!arg4) {
43804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43805     return ;
43806   }
43807   arg5 = (Dali::Vector2 *)jarg5;
43808   if (!arg5) {
43809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43810     return ;
43811   }
43812   {
43813     try {
43814       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
43815     } catch (std::out_of_range& e) {
43816       {
43817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43818       };
43819     } catch (std::exception& e) {
43820       {
43821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43822       };
43823     } catch (Dali::DaliException e) {
43824       {
43825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43826       };
43827     } catch (...) {
43828       {
43829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43830       };
43831     }
43832   }
43833
43834 }
43835
43836
43837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
43838   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43839   SwigValueWrapper< Dali::Property > arg2 ;
43840   SwigValueWrapper< Dali::Property > arg3 ;
43841   Dali::Vector2 *arg4 = 0 ;
43842   Dali::Property *argp2 ;
43843   Dali::Property *argp3 ;
43844
43845   arg1 = (Dali::LinearConstrainer *)jarg1;
43846   argp2 = (Dali::Property *)jarg2;
43847   if (!argp2) {
43848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43849     return ;
43850   }
43851   arg2 = *argp2;
43852   argp3 = (Dali::Property *)jarg3;
43853   if (!argp3) {
43854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43855     return ;
43856   }
43857   arg3 = *argp3;
43858   arg4 = (Dali::Vector2 *)jarg4;
43859   if (!arg4) {
43860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43861     return ;
43862   }
43863   {
43864     try {
43865       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
43866     } catch (std::out_of_range& e) {
43867       {
43868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43869       };
43870     } catch (std::exception& e) {
43871       {
43872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43873       };
43874     } catch (Dali::DaliException e) {
43875       {
43876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43877       };
43878     } catch (...) {
43879       {
43880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43881       };
43882     }
43883   }
43884
43885 }
43886
43887
43888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
43889   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43890   Dali::Handle *arg2 = 0 ;
43891
43892   arg1 = (Dali::LinearConstrainer *)jarg1;
43893   arg2 = (Dali::Handle *)jarg2;
43894   if (!arg2) {
43895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
43896     return ;
43897   }
43898   {
43899     try {
43900       (arg1)->Remove(*arg2);
43901     } catch (std::out_of_range& e) {
43902       {
43903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43904       };
43905     } catch (std::exception& e) {
43906       {
43907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43908       };
43909     } catch (Dali::DaliException e) {
43910       {
43911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43912       };
43913     } catch (...) {
43914       {
43915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43916       };
43917     }
43918   }
43919
43920 }
43921
43922
43923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
43924   int jresult ;
43925   int result;
43926
43927   result = (int)Dali::PathConstrainer::Property::FORWARD;
43928   jresult = (int)result;
43929   return jresult;
43930 }
43931
43932
43933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
43934   int jresult ;
43935   int result;
43936
43937   result = (int)Dali::PathConstrainer::Property::POINTS;
43938   jresult = (int)result;
43939   return jresult;
43940 }
43941
43942
43943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
43944   int jresult ;
43945   int result;
43946
43947   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
43948   jresult = (int)result;
43949   return jresult;
43950 }
43951
43952
43953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
43954   void * jresult ;
43955   Dali::PathConstrainer::Property *result = 0 ;
43956
43957   {
43958     try {
43959       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
43960     } catch (std::out_of_range& e) {
43961       {
43962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43963       };
43964     } catch (std::exception& e) {
43965       {
43966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43967       };
43968     } catch (Dali::DaliException e) {
43969       {
43970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43971       };
43972     } catch (...) {
43973       {
43974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43975       };
43976     }
43977   }
43978
43979   jresult = (void *)result;
43980   return jresult;
43981 }
43982
43983
43984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
43985   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
43986
43987   arg1 = (Dali::PathConstrainer::Property *)jarg1;
43988   {
43989     try {
43990       delete arg1;
43991     } catch (std::out_of_range& e) {
43992       {
43993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43994       };
43995     } catch (std::exception& e) {
43996       {
43997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43998       };
43999     } catch (Dali::DaliException e) {
44000       {
44001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44002       };
44003     } catch (...) {
44004       {
44005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44006       };
44007     }
44008   }
44009
44010 }
44011
44012
44013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44014   void * jresult ;
44015   Dali::PathConstrainer result;
44016
44017   {
44018     try {
44019       result = Dali::PathConstrainer::New();
44020     } catch (std::out_of_range& e) {
44021       {
44022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44023       };
44024     } catch (std::exception& e) {
44025       {
44026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44027       };
44028     } catch (Dali::DaliException e) {
44029       {
44030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44031       };
44032     } catch (...) {
44033       {
44034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44035       };
44036     }
44037   }
44038
44039   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44040   return jresult;
44041 }
44042
44043
44044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44045   void * jresult ;
44046   Dali::BaseHandle arg1 ;
44047   Dali::BaseHandle *argp1 ;
44048   Dali::PathConstrainer result;
44049
44050   argp1 = (Dali::BaseHandle *)jarg1;
44051   if (!argp1) {
44052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44053     return 0;
44054   }
44055   arg1 = *argp1;
44056   {
44057     try {
44058       result = Dali::PathConstrainer::DownCast(arg1);
44059     } catch (std::out_of_range& e) {
44060       {
44061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44062       };
44063     } catch (std::exception& e) {
44064       {
44065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44066       };
44067     } catch (Dali::DaliException e) {
44068       {
44069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44070       };
44071     } catch (...) {
44072       {
44073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44074       };
44075     }
44076   }
44077
44078   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44079   return jresult;
44080 }
44081
44082
44083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44084   void * jresult ;
44085   Dali::PathConstrainer *result = 0 ;
44086
44087   {
44088     try {
44089       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44090     } catch (std::out_of_range& e) {
44091       {
44092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44093       };
44094     } catch (std::exception& e) {
44095       {
44096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44097       };
44098     } catch (Dali::DaliException e) {
44099       {
44100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44101       };
44102     } catch (...) {
44103       {
44104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44105       };
44106     }
44107   }
44108
44109   jresult = (void *)result;
44110   return jresult;
44111 }
44112
44113
44114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44115   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44116
44117   arg1 = (Dali::PathConstrainer *)jarg1;
44118   {
44119     try {
44120       delete arg1;
44121     } catch (std::out_of_range& e) {
44122       {
44123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44124       };
44125     } catch (std::exception& e) {
44126       {
44127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44128       };
44129     } catch (Dali::DaliException e) {
44130       {
44131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44132       };
44133     } catch (...) {
44134       {
44135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44136       };
44137     }
44138   }
44139
44140 }
44141
44142
44143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44144   void * jresult ;
44145   Dali::PathConstrainer *arg1 = 0 ;
44146   Dali::PathConstrainer *result = 0 ;
44147
44148   arg1 = (Dali::PathConstrainer *)jarg1;
44149   if (!arg1) {
44150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44151     return 0;
44152   }
44153   {
44154     try {
44155       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44156     } catch (std::out_of_range& e) {
44157       {
44158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44159       };
44160     } catch (std::exception& e) {
44161       {
44162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44163       };
44164     } catch (Dali::DaliException e) {
44165       {
44166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44167       };
44168     } catch (...) {
44169       {
44170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44171       };
44172     }
44173   }
44174
44175   jresult = (void *)result;
44176   return jresult;
44177 }
44178
44179
44180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44181   void * jresult ;
44182   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44183   Dali::PathConstrainer *arg2 = 0 ;
44184   Dali::PathConstrainer *result = 0 ;
44185
44186   arg1 = (Dali::PathConstrainer *)jarg1;
44187   arg2 = (Dali::PathConstrainer *)jarg2;
44188   if (!arg2) {
44189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44190     return 0;
44191   }
44192   {
44193     try {
44194       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44195     } catch (std::out_of_range& e) {
44196       {
44197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44198       };
44199     } catch (std::exception& e) {
44200       {
44201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44202       };
44203     } catch (Dali::DaliException e) {
44204       {
44205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44206       };
44207     } catch (...) {
44208       {
44209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44210       };
44211     }
44212   }
44213
44214   jresult = (void *)result;
44215   return jresult;
44216 }
44217
44218
44219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44220   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44221   SwigValueWrapper< Dali::Property > arg2 ;
44222   SwigValueWrapper< Dali::Property > arg3 ;
44223   Dali::Vector2 *arg4 = 0 ;
44224   Dali::Vector2 *arg5 = 0 ;
44225   Dali::Property *argp2 ;
44226   Dali::Property *argp3 ;
44227
44228   arg1 = (Dali::PathConstrainer *)jarg1;
44229   argp2 = (Dali::Property *)jarg2;
44230   if (!argp2) {
44231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44232     return ;
44233   }
44234   arg2 = *argp2;
44235   argp3 = (Dali::Property *)jarg3;
44236   if (!argp3) {
44237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44238     return ;
44239   }
44240   arg3 = *argp3;
44241   arg4 = (Dali::Vector2 *)jarg4;
44242   if (!arg4) {
44243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44244     return ;
44245   }
44246   arg5 = (Dali::Vector2 *)jarg5;
44247   if (!arg5) {
44248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44249     return ;
44250   }
44251   {
44252     try {
44253       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44254     } catch (std::out_of_range& e) {
44255       {
44256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44257       };
44258     } catch (std::exception& e) {
44259       {
44260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44261       };
44262     } catch (Dali::DaliException e) {
44263       {
44264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44265       };
44266     } catch (...) {
44267       {
44268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44269       };
44270     }
44271   }
44272
44273 }
44274
44275
44276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44277   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44278   SwigValueWrapper< Dali::Property > arg2 ;
44279   SwigValueWrapper< Dali::Property > arg3 ;
44280   Dali::Vector2 *arg4 = 0 ;
44281   Dali::Property *argp2 ;
44282   Dali::Property *argp3 ;
44283
44284   arg1 = (Dali::PathConstrainer *)jarg1;
44285   argp2 = (Dali::Property *)jarg2;
44286   if (!argp2) {
44287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44288     return ;
44289   }
44290   arg2 = *argp2;
44291   argp3 = (Dali::Property *)jarg3;
44292   if (!argp3) {
44293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44294     return ;
44295   }
44296   arg3 = *argp3;
44297   arg4 = (Dali::Vector2 *)jarg4;
44298   if (!arg4) {
44299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44300     return ;
44301   }
44302   {
44303     try {
44304       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44305     } catch (std::out_of_range& e) {
44306       {
44307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44308       };
44309     } catch (std::exception& e) {
44310       {
44311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44312       };
44313     } catch (Dali::DaliException e) {
44314       {
44315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44316       };
44317     } catch (...) {
44318       {
44319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44320       };
44321     }
44322   }
44323
44324 }
44325
44326
44327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44328   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44329   Dali::Handle *arg2 = 0 ;
44330
44331   arg1 = (Dali::PathConstrainer *)jarg1;
44332   arg2 = (Dali::Handle *)jarg2;
44333   if (!arg2) {
44334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44335     return ;
44336   }
44337   {
44338     try {
44339       (arg1)->Remove(*arg2);
44340     } catch (std::out_of_range& e) {
44341       {
44342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44343       };
44344     } catch (std::exception& e) {
44345       {
44346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44347       };
44348     } catch (Dali::DaliException e) {
44349       {
44350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44351       };
44352     } catch (...) {
44353       {
44354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44355       };
44356     }
44357   }
44358
44359 }
44360
44361
44362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44363   int jresult ;
44364   Dali::FittingMode::Type result;
44365
44366   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44367   jresult = (int)result;
44368   return jresult;
44369 }
44370
44371
44372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44373   int jresult ;
44374   Dali::SamplingMode::Type result;
44375
44376   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44377   jresult = (int)result;
44378   return jresult;
44379 }
44380
44381
44382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_CreateResource(void * jarg1) {
44383   unsigned int jresult ;
44384   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44385   bool result;
44386
44387   arg1 = (Dali::NativeImageInterface *)jarg1;
44388   {
44389     try {
44390       result = (bool)(arg1)->CreateResource();
44391     } catch (std::out_of_range& e) {
44392       {
44393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44394       };
44395     } catch (std::exception& e) {
44396       {
44397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44398       };
44399     } catch (Dali::DaliException e) {
44400       {
44401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44402       };
44403     } catch (...) {
44404       {
44405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44406       };
44407     }
44408   }
44409
44410   jresult = result;
44411   return jresult;
44412 }
44413
44414
44415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_DestroyResource(void * jarg1) {
44416   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44417
44418   arg1 = (Dali::NativeImageInterface *)jarg1;
44419   {
44420     try {
44421       (arg1)->DestroyResource();
44422     } catch (std::out_of_range& e) {
44423       {
44424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44425       };
44426     } catch (std::exception& e) {
44427       {
44428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44429       };
44430     } catch (Dali::DaliException e) {
44431       {
44432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44433       };
44434     } catch (...) {
44435       {
44436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44437       };
44438     }
44439   }
44440
44441 }
44442
44443
44444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
44445   unsigned int jresult ;
44446   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44447   unsigned int result;
44448
44449   arg1 = (Dali::NativeImageInterface *)jarg1;
44450   {
44451     try {
44452       result = (unsigned int)(arg1)->TargetTexture();
44453     } catch (std::out_of_range& e) {
44454       {
44455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44456       };
44457     } catch (std::exception& e) {
44458       {
44459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44460       };
44461     } catch (Dali::DaliException e) {
44462       {
44463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44464       };
44465     } catch (...) {
44466       {
44467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44468       };
44469     }
44470   }
44471
44472   jresult = result;
44473   return jresult;
44474 }
44475
44476
44477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
44478   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44479
44480   arg1 = (Dali::NativeImageInterface *)jarg1;
44481   {
44482     try {
44483       (arg1)->PrepareTexture();
44484     } catch (std::out_of_range& e) {
44485       {
44486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44487       };
44488     } catch (std::exception& e) {
44489       {
44490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44491       };
44492     } catch (Dali::DaliException e) {
44493       {
44494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44495       };
44496     } catch (...) {
44497       {
44498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44499       };
44500     }
44501   }
44502
44503 }
44504
44505
44506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
44507   unsigned int jresult ;
44508   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44509   unsigned int result;
44510
44511   arg1 = (Dali::NativeImageInterface *)jarg1;
44512   {
44513     try {
44514       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
44515     } catch (std::out_of_range& e) {
44516       {
44517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44518       };
44519     } catch (std::exception& e) {
44520       {
44521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44522       };
44523     } catch (Dali::DaliException e) {
44524       {
44525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44526       };
44527     } catch (...) {
44528       {
44529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44530       };
44531     }
44532   }
44533
44534   jresult = result;
44535   return jresult;
44536 }
44537
44538
44539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
44540   unsigned int jresult ;
44541   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44542   unsigned int result;
44543
44544   arg1 = (Dali::NativeImageInterface *)jarg1;
44545   {
44546     try {
44547       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
44548     } catch (std::out_of_range& e) {
44549       {
44550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44551       };
44552     } catch (std::exception& e) {
44553       {
44554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44555       };
44556     } catch (Dali::DaliException e) {
44557       {
44558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44559       };
44560     } catch (...) {
44561       {
44562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44563       };
44564     }
44565   }
44566
44567   jresult = result;
44568   return jresult;
44569 }
44570
44571
44572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
44573   unsigned int jresult ;
44574   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44575   bool result;
44576
44577   arg1 = (Dali::NativeImageInterface *)jarg1;
44578   {
44579     try {
44580       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
44581     } catch (std::out_of_range& e) {
44582       {
44583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44584       };
44585     } catch (std::exception& e) {
44586       {
44587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44588       };
44589     } catch (Dali::DaliException e) {
44590       {
44591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44592       };
44593     } catch (...) {
44594       {
44595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44596       };
44597     }
44598   }
44599
44600   jresult = result;
44601   return jresult;
44602 }
44603
44604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
44605   int jresult ;
44606   int result;
44607
44608   result = (int)Dali::CameraActor::Property::TYPE;
44609   jresult = (int)result;
44610   return jresult;
44611 }
44612
44613
44614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
44615   int jresult ;
44616   int result;
44617
44618   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
44619   jresult = (int)result;
44620   return jresult;
44621 }
44622
44623
44624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
44625   int jresult ;
44626   int result;
44627
44628   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
44629   jresult = (int)result;
44630   return jresult;
44631 }
44632
44633
44634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
44635   int jresult ;
44636   int result;
44637
44638   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
44639   jresult = (int)result;
44640   return jresult;
44641 }
44642
44643
44644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
44645   int jresult ;
44646   int result;
44647
44648   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
44649   jresult = (int)result;
44650   return jresult;
44651 }
44652
44653
44654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
44655   int jresult ;
44656   int result;
44657
44658   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
44659   jresult = (int)result;
44660   return jresult;
44661 }
44662
44663
44664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
44665   int jresult ;
44666   int result;
44667
44668   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
44669   jresult = (int)result;
44670   return jresult;
44671 }
44672
44673
44674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
44675   int jresult ;
44676   int result;
44677
44678   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
44679   jresult = (int)result;
44680   return jresult;
44681 }
44682
44683
44684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
44685   int jresult ;
44686   int result;
44687
44688   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
44689   jresult = (int)result;
44690   return jresult;
44691 }
44692
44693
44694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
44695   int jresult ;
44696   int result;
44697
44698   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
44699   jresult = (int)result;
44700   return jresult;
44701 }
44702
44703
44704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
44705   int jresult ;
44706   int result;
44707
44708   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
44709   jresult = (int)result;
44710   return jresult;
44711 }
44712
44713
44714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
44715   int jresult ;
44716   int result;
44717
44718   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
44719   jresult = (int)result;
44720   return jresult;
44721 }
44722
44723
44724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
44725   int jresult ;
44726   int result;
44727
44728   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
44729   jresult = (int)result;
44730   return jresult;
44731 }
44732
44733
44734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
44735   int jresult ;
44736   int result;
44737
44738   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
44739   jresult = (int)result;
44740   return jresult;
44741 }
44742
44743
44744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
44745   void * jresult ;
44746   Dali::CameraActor::Property *result = 0 ;
44747
44748   {
44749     try {
44750       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
44751     } catch (std::out_of_range& e) {
44752       {
44753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44754       };
44755     } catch (std::exception& e) {
44756       {
44757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44758       };
44759     } catch (Dali::DaliException e) {
44760       {
44761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44762       };
44763     } catch (...) {
44764       {
44765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44766       };
44767     }
44768   }
44769
44770   jresult = (void *)result;
44771   return jresult;
44772 }
44773
44774
44775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
44776   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
44777
44778   arg1 = (Dali::CameraActor::Property *)jarg1;
44779   {
44780     try {
44781       delete arg1;
44782     } catch (std::out_of_range& e) {
44783       {
44784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44785       };
44786     } catch (std::exception& e) {
44787       {
44788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44789       };
44790     } catch (Dali::DaliException e) {
44791       {
44792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44793       };
44794     } catch (...) {
44795       {
44796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44797       };
44798     }
44799   }
44800
44801 }
44802
44803
44804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
44805   void * jresult ;
44806   Dali::CameraActor *result = 0 ;
44807
44808   {
44809     try {
44810       result = (Dali::CameraActor *)new Dali::CameraActor();
44811     } catch (std::out_of_range& e) {
44812       {
44813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44814       };
44815     } catch (std::exception& e) {
44816       {
44817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44818       };
44819     } catch (Dali::DaliException e) {
44820       {
44821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44822       };
44823     } catch (...) {
44824       {
44825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44826       };
44827     }
44828   }
44829
44830   jresult = (void *)result;
44831   return jresult;
44832 }
44833
44834
44835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
44836   void * jresult ;
44837   Dali::CameraActor result;
44838
44839   {
44840     try {
44841       result = Dali::CameraActor::New();
44842     } catch (std::out_of_range& e) {
44843       {
44844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44845       };
44846     } catch (std::exception& e) {
44847       {
44848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44849       };
44850     } catch (Dali::DaliException e) {
44851       {
44852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44853       };
44854     } catch (...) {
44855       {
44856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44857       };
44858     }
44859   }
44860
44861   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44862   return jresult;
44863 }
44864
44865
44866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
44867   void * jresult ;
44868   Dali::Size *arg1 = 0 ;
44869   Dali::CameraActor result;
44870
44871   arg1 = (Dali::Size *)jarg1;
44872   if (!arg1) {
44873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44874     return 0;
44875   }
44876   {
44877     try {
44878       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
44879     } catch (std::out_of_range& e) {
44880       {
44881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44882       };
44883     } catch (std::exception& e) {
44884       {
44885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44886       };
44887     } catch (Dali::DaliException e) {
44888       {
44889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44890       };
44891     } catch (...) {
44892       {
44893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44894       };
44895     }
44896   }
44897
44898   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44899   return jresult;
44900 }
44901
44902
44903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
44904   void * jresult ;
44905   Dali::BaseHandle arg1 ;
44906   Dali::BaseHandle *argp1 ;
44907   Dali::CameraActor result;
44908
44909   argp1 = (Dali::BaseHandle *)jarg1;
44910   if (!argp1) {
44911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44912     return 0;
44913   }
44914   arg1 = *argp1;
44915   {
44916     try {
44917       result = Dali::CameraActor::DownCast(arg1);
44918     } catch (std::out_of_range& e) {
44919       {
44920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44921       };
44922     } catch (std::exception& e) {
44923       {
44924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44925       };
44926     } catch (Dali::DaliException e) {
44927       {
44928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44929       };
44930     } catch (...) {
44931       {
44932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44933       };
44934     }
44935   }
44936
44937   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44938   return jresult;
44939 }
44940
44941
44942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
44943   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44944
44945   arg1 = (Dali::CameraActor *)jarg1;
44946   {
44947     try {
44948       delete arg1;
44949     } catch (std::out_of_range& e) {
44950       {
44951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44952       };
44953     } catch (std::exception& e) {
44954       {
44955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44956       };
44957     } catch (Dali::DaliException e) {
44958       {
44959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44960       };
44961     } catch (...) {
44962       {
44963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44964       };
44965     }
44966   }
44967
44968 }
44969
44970
44971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
44972   void * jresult ;
44973   Dali::CameraActor *arg1 = 0 ;
44974   Dali::CameraActor *result = 0 ;
44975
44976   arg1 = (Dali::CameraActor *)jarg1;
44977   if (!arg1) {
44978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44979     return 0;
44980   }
44981   {
44982     try {
44983       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
44984     } catch (std::out_of_range& e) {
44985       {
44986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44987       };
44988     } catch (std::exception& e) {
44989       {
44990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44991       };
44992     } catch (Dali::DaliException e) {
44993       {
44994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44995       };
44996     } catch (...) {
44997       {
44998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44999       };
45000     }
45001   }
45002
45003   jresult = (void *)result;
45004   return jresult;
45005 }
45006
45007
45008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
45009   void * jresult ;
45010   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45011   Dali::CameraActor *arg2 = 0 ;
45012   Dali::CameraActor *result = 0 ;
45013
45014   arg1 = (Dali::CameraActor *)jarg1;
45015   arg2 = (Dali::CameraActor *)jarg2;
45016   if (!arg2) {
45017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
45018     return 0;
45019   }
45020   {
45021     try {
45022       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
45023     } catch (std::out_of_range& e) {
45024       {
45025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45026       };
45027     } catch (std::exception& e) {
45028       {
45029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45030       };
45031     } catch (Dali::DaliException e) {
45032       {
45033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45034       };
45035     } catch (...) {
45036       {
45037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45038       };
45039     }
45040   }
45041
45042   jresult = (void *)result;
45043   return jresult;
45044 }
45045
45046
45047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
45048   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45049   Dali::Camera::Type arg2 ;
45050
45051   arg1 = (Dali::CameraActor *)jarg1;
45052   arg2 = (Dali::Camera::Type)jarg2;
45053   {
45054     try {
45055       (arg1)->SetType(arg2);
45056     } catch (std::out_of_range& e) {
45057       {
45058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45059       };
45060     } catch (std::exception& e) {
45061       {
45062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45063       };
45064     } catch (Dali::DaliException e) {
45065       {
45066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45067       };
45068     } catch (...) {
45069       {
45070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45071       };
45072     }
45073   }
45074
45075 }
45076
45077
45078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
45079   int jresult ;
45080   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45081   Dali::Camera::Type result;
45082
45083   arg1 = (Dali::CameraActor *)jarg1;
45084   {
45085     try {
45086       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
45087     } catch (std::out_of_range& e) {
45088       {
45089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45090       };
45091     } catch (std::exception& e) {
45092       {
45093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45094       };
45095     } catch (Dali::DaliException e) {
45096       {
45097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45098       };
45099     } catch (...) {
45100       {
45101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45102       };
45103     }
45104   }
45105
45106   jresult = (int)result;
45107   return jresult;
45108 }
45109
45110
45111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
45112   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45113   Dali::Camera::ProjectionMode arg2 ;
45114
45115   arg1 = (Dali::CameraActor *)jarg1;
45116   arg2 = (Dali::Camera::ProjectionMode)jarg2;
45117   {
45118     try {
45119       (arg1)->SetProjectionMode(arg2);
45120     } catch (std::out_of_range& e) {
45121       {
45122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45123       };
45124     } catch (std::exception& e) {
45125       {
45126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45127       };
45128     } catch (Dali::DaliException e) {
45129       {
45130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45131       };
45132     } catch (...) {
45133       {
45134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45135       };
45136     }
45137   }
45138
45139 }
45140
45141
45142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
45143   int jresult ;
45144   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45145   Dali::Camera::ProjectionMode result;
45146
45147   arg1 = (Dali::CameraActor *)jarg1;
45148   {
45149     try {
45150       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
45151     } catch (std::out_of_range& e) {
45152       {
45153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45154       };
45155     } catch (std::exception& e) {
45156       {
45157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45158       };
45159     } catch (Dali::DaliException e) {
45160       {
45161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45162       };
45163     } catch (...) {
45164       {
45165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45166       };
45167     }
45168   }
45169
45170   jresult = (int)result;
45171   return jresult;
45172 }
45173
45174
45175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
45176   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45177   float arg2 ;
45178
45179   arg1 = (Dali::CameraActor *)jarg1;
45180   arg2 = (float)jarg2;
45181   {
45182     try {
45183       (arg1)->SetFieldOfView(arg2);
45184     } catch (std::out_of_range& e) {
45185       {
45186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45187       };
45188     } catch (std::exception& e) {
45189       {
45190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45191       };
45192     } catch (Dali::DaliException e) {
45193       {
45194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45195       };
45196     } catch (...) {
45197       {
45198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45199       };
45200     }
45201   }
45202
45203 }
45204
45205
45206 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
45207   float jresult ;
45208   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45209   float result;
45210
45211   arg1 = (Dali::CameraActor *)jarg1;
45212   {
45213     try {
45214       result = (float)(arg1)->GetFieldOfView();
45215     } catch (std::out_of_range& e) {
45216       {
45217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45218       };
45219     } catch (std::exception& e) {
45220       {
45221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45222       };
45223     } catch (Dali::DaliException e) {
45224       {
45225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45226       };
45227     } catch (...) {
45228       {
45229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45230       };
45231     }
45232   }
45233
45234   jresult = result;
45235   return jresult;
45236 }
45237
45238
45239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
45240   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45241   float arg2 ;
45242
45243   arg1 = (Dali::CameraActor *)jarg1;
45244   arg2 = (float)jarg2;
45245   {
45246     try {
45247       (arg1)->SetAspectRatio(arg2);
45248     } catch (std::out_of_range& e) {
45249       {
45250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45251       };
45252     } catch (std::exception& e) {
45253       {
45254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45255       };
45256     } catch (Dali::DaliException e) {
45257       {
45258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45259       };
45260     } catch (...) {
45261       {
45262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45263       };
45264     }
45265   }
45266
45267 }
45268
45269
45270 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
45271   float jresult ;
45272   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45273   float result;
45274
45275   arg1 = (Dali::CameraActor *)jarg1;
45276   {
45277     try {
45278       result = (float)(arg1)->GetAspectRatio();
45279     } catch (std::out_of_range& e) {
45280       {
45281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45282       };
45283     } catch (std::exception& e) {
45284       {
45285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45286       };
45287     } catch (Dali::DaliException e) {
45288       {
45289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45290       };
45291     } catch (...) {
45292       {
45293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45294       };
45295     }
45296   }
45297
45298   jresult = result;
45299   return jresult;
45300 }
45301
45302
45303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
45304   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45305   float arg2 ;
45306
45307   arg1 = (Dali::CameraActor *)jarg1;
45308   arg2 = (float)jarg2;
45309   {
45310     try {
45311       (arg1)->SetNearClippingPlane(arg2);
45312     } catch (std::out_of_range& e) {
45313       {
45314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45315       };
45316     } catch (std::exception& e) {
45317       {
45318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45319       };
45320     } catch (Dali::DaliException e) {
45321       {
45322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45323       };
45324     } catch (...) {
45325       {
45326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45327       };
45328     }
45329   }
45330
45331 }
45332
45333
45334 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
45335   float jresult ;
45336   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45337   float result;
45338
45339   arg1 = (Dali::CameraActor *)jarg1;
45340   {
45341     try {
45342       result = (float)(arg1)->GetNearClippingPlane();
45343     } catch (std::out_of_range& e) {
45344       {
45345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45346       };
45347     } catch (std::exception& e) {
45348       {
45349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45350       };
45351     } catch (Dali::DaliException e) {
45352       {
45353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45354       };
45355     } catch (...) {
45356       {
45357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45358       };
45359     }
45360   }
45361
45362   jresult = result;
45363   return jresult;
45364 }
45365
45366
45367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
45368   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45369   float arg2 ;
45370
45371   arg1 = (Dali::CameraActor *)jarg1;
45372   arg2 = (float)jarg2;
45373   {
45374     try {
45375       (arg1)->SetFarClippingPlane(arg2);
45376     } catch (std::out_of_range& e) {
45377       {
45378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45379       };
45380     } catch (std::exception& e) {
45381       {
45382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45383       };
45384     } catch (Dali::DaliException e) {
45385       {
45386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45387       };
45388     } catch (...) {
45389       {
45390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45391       };
45392     }
45393   }
45394
45395 }
45396
45397
45398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
45399   float jresult ;
45400   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45401   float result;
45402
45403   arg1 = (Dali::CameraActor *)jarg1;
45404   {
45405     try {
45406       result = (float)(arg1)->GetFarClippingPlane();
45407     } catch (std::out_of_range& e) {
45408       {
45409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45410       };
45411     } catch (std::exception& e) {
45412       {
45413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45414       };
45415     } catch (Dali::DaliException e) {
45416       {
45417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45418       };
45419     } catch (...) {
45420       {
45421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45422       };
45423     }
45424   }
45425
45426   jresult = result;
45427   return jresult;
45428 }
45429
45430
45431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
45432   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45433   Dali::Vector3 *arg2 = 0 ;
45434
45435   arg1 = (Dali::CameraActor *)jarg1;
45436   arg2 = (Dali::Vector3 *)jarg2;
45437   if (!arg2) {
45438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
45439     return ;
45440   }
45441   {
45442     try {
45443       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
45444     } catch (std::out_of_range& e) {
45445       {
45446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45447       };
45448     } catch (std::exception& e) {
45449       {
45450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45451       };
45452     } catch (Dali::DaliException e) {
45453       {
45454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45455       };
45456     } catch (...) {
45457       {
45458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45459       };
45460     }
45461   }
45462
45463 }
45464
45465
45466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
45467   void * jresult ;
45468   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45469   Dali::Vector3 result;
45470
45471   arg1 = (Dali::CameraActor *)jarg1;
45472   {
45473     try {
45474       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
45475     } catch (std::out_of_range& e) {
45476       {
45477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45478       };
45479     } catch (std::exception& e) {
45480       {
45481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45482       };
45483     } catch (Dali::DaliException e) {
45484       {
45485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45486       };
45487     } catch (...) {
45488       {
45489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45490       };
45491     }
45492   }
45493
45494   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
45495   return jresult;
45496 }
45497
45498
45499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
45500   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45501   bool arg2 ;
45502
45503   arg1 = (Dali::CameraActor *)jarg1;
45504   arg2 = jarg2 ? true : false;
45505   {
45506     try {
45507       (arg1)->SetInvertYAxis(arg2);
45508     } catch (std::out_of_range& e) {
45509       {
45510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45511       };
45512     } catch (std::exception& e) {
45513       {
45514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45515       };
45516     } catch (Dali::DaliException e) {
45517       {
45518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45519       };
45520     } catch (...) {
45521       {
45522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45523       };
45524     }
45525   }
45526
45527 }
45528
45529
45530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
45531   unsigned int jresult ;
45532   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45533   bool result;
45534
45535   arg1 = (Dali::CameraActor *)jarg1;
45536   {
45537     try {
45538       result = (bool)(arg1)->GetInvertYAxis();
45539     } catch (std::out_of_range& e) {
45540       {
45541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45542       };
45543     } catch (std::exception& e) {
45544       {
45545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45546       };
45547     } catch (Dali::DaliException e) {
45548       {
45549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45550       };
45551     } catch (...) {
45552       {
45553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45554       };
45555     }
45556   }
45557
45558   jresult = result;
45559   return jresult;
45560 }
45561
45562
45563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
45564   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45565   Dali::Size *arg2 = 0 ;
45566
45567   arg1 = (Dali::CameraActor *)jarg1;
45568   arg2 = (Dali::Size *)jarg2;
45569   if (!arg2) {
45570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45571     return ;
45572   }
45573   {
45574     try {
45575       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
45576     } catch (std::out_of_range& e) {
45577       {
45578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45579       };
45580     } catch (std::exception& e) {
45581       {
45582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45583       };
45584     } catch (Dali::DaliException e) {
45585       {
45586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45587       };
45588     } catch (...) {
45589       {
45590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45591       };
45592     }
45593   }
45594
45595 }
45596
45597
45598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
45599   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45600   Dali::Size *arg2 = 0 ;
45601
45602   arg1 = (Dali::CameraActor *)jarg1;
45603   arg2 = (Dali::Size *)jarg2;
45604   if (!arg2) {
45605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45606     return ;
45607   }
45608   {
45609     try {
45610       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
45611     } catch (std::out_of_range& e) {
45612       {
45613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45614       };
45615     } catch (std::exception& e) {
45616       {
45617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45618       };
45619     } catch (Dali::DaliException e) {
45620       {
45621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45622       };
45623     } catch (...) {
45624       {
45625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45626       };
45627     }
45628   }
45629
45630 }
45631
45632
45633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
45634   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45635   float arg2 ;
45636   float arg3 ;
45637   float arg4 ;
45638   float arg5 ;
45639   float arg6 ;
45640   float arg7 ;
45641
45642   arg1 = (Dali::CameraActor *)jarg1;
45643   arg2 = (float)jarg2;
45644   arg3 = (float)jarg3;
45645   arg4 = (float)jarg4;
45646   arg5 = (float)jarg5;
45647   arg6 = (float)jarg6;
45648   arg7 = (float)jarg7;
45649   {
45650     try {
45651       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
45652     } catch (std::out_of_range& e) {
45653       {
45654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45655       };
45656     } catch (std::exception& e) {
45657       {
45658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45659       };
45660     } catch (Dali::DaliException e) {
45661       {
45662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45663       };
45664     } catch (...) {
45665       {
45666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45667       };
45668     }
45669   }
45670
45671 }
45672
45673
45674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
45675   void * jresult ;
45676   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45677
45678   {
45679     try {
45680       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
45681     } catch (std::out_of_range& e) {
45682       {
45683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45684       };
45685     } catch (std::exception& e) {
45686       {
45687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45688       };
45689     } catch (Dali::DaliException e) {
45690       {
45691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45692       };
45693     } catch (...) {
45694       {
45695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45696       };
45697     }
45698   }
45699
45700   jresult = (void *)result;
45701   return jresult;
45702 }
45703
45704
45705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
45706   void * jresult ;
45707   std::string arg1 ;
45708   Dali::Property::Value arg2 ;
45709   Dali::Property::Value *argp2 ;
45710   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45711
45712   if (!jarg1) {
45713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45714     return 0;
45715   }
45716   (&arg1)->assign(jarg1);
45717   argp2 = (Dali::Property::Value *)jarg2;
45718   if (!argp2) {
45719     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
45720     return 0;
45721   }
45722   arg2 = *argp2;
45723   {
45724     try {
45725       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
45726     } catch (std::out_of_range& e) {
45727       {
45728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45729       };
45730     } catch (std::exception& e) {
45731       {
45732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45733       };
45734     } catch (Dali::DaliException e) {
45735       {
45736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45737       };
45738     } catch (...) {
45739       {
45740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45741       };
45742     }
45743   }
45744
45745   jresult = (void *)result;
45746   return jresult;
45747 }
45748
45749
45750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
45751   void * jresult ;
45752   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
45753   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45754
45755   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45756   if (!arg1) {
45757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
45758     return 0;
45759   }
45760   {
45761     try {
45762       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);
45763     } catch (std::out_of_range& e) {
45764       {
45765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45766       };
45767     } catch (std::exception& e) {
45768       {
45769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45770       };
45771     } catch (Dali::DaliException e) {
45772       {
45773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45774       };
45775     } catch (...) {
45776       {
45777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45778       };
45779     }
45780   }
45781
45782   jresult = (void *)result;
45783   return jresult;
45784 }
45785
45786
45787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
45788   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45789   std::string *arg2 = 0 ;
45790
45791   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45792   if (!jarg2) {
45793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45794     return ;
45795   }
45796   std::string arg2_str(jarg2);
45797   arg2 = &arg2_str;
45798   if (arg1) (arg1)->first = *arg2;
45799
45800   //argout typemap for const std::string&
45801
45802 }
45803
45804
45805 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
45806   char * jresult ;
45807   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45808   std::string *result = 0 ;
45809
45810   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45811   result = (std::string *) & ((arg1)->first);
45812   jresult = SWIG_csharp_string_callback(result->c_str());
45813   return jresult;
45814 }
45815
45816
45817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
45818   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45819   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
45820
45821   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45822   arg2 = (Dali::Property::Value *)jarg2;
45823   if (arg1) (arg1)->second = *arg2;
45824 }
45825
45826
45827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
45828   void * jresult ;
45829   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45830   Dali::Property::Value *result = 0 ;
45831
45832   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45833   result = (Dali::Property::Value *)& ((arg1)->second);
45834   jresult = (void *)result;
45835   return jresult;
45836 }
45837
45838
45839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
45840   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45841
45842   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45843   {
45844     try {
45845       delete arg1;
45846     } catch (std::out_of_range& e) {
45847       {
45848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45849       };
45850     } catch (std::exception& e) {
45851       {
45852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45853       };
45854     } catch (Dali::DaliException e) {
45855       {
45856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45857       };
45858     } catch (...) {
45859       {
45860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45861       };
45862     }
45863   }
45864
45865 }
45866
45867
45868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
45869   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45870
45871   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45872   {
45873     try {
45874       (arg1)->clear();
45875     } catch (std::out_of_range& e) {
45876       {
45877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45878       };
45879     } catch (std::exception& e) {
45880       {
45881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45882       };
45883     } catch (Dali::DaliException e) {
45884       {
45885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45886       };
45887     } catch (...) {
45888       {
45889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45890       };
45891     }
45892   }
45893
45894 }
45895
45896
45897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
45898   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45899   Dali::TouchPoint *arg2 = 0 ;
45900
45901   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45902   arg2 = (Dali::TouchPoint *)jarg2;
45903   if (!arg2) {
45904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45905     return ;
45906   }
45907   {
45908     try {
45909       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
45910     } catch (std::out_of_range& e) {
45911       {
45912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45913       };
45914     } catch (std::exception& e) {
45915       {
45916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45917       };
45918     } catch (Dali::DaliException e) {
45919       {
45920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45921       };
45922     } catch (...) {
45923       {
45924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45925       };
45926     }
45927   }
45928
45929 }
45930
45931
45932 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
45933   unsigned long jresult ;
45934   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45935   std::vector< Dali::TouchPoint >::size_type result;
45936
45937   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45938   {
45939     try {
45940       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
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 = (unsigned long)result;
45961   return jresult;
45962 }
45963
45964
45965 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
45966   unsigned long jresult ;
45967   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45968   std::vector< Dali::TouchPoint >::size_type result;
45969
45970   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45971   {
45972     try {
45973       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
45974     } catch (std::out_of_range& e) {
45975       {
45976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45977       };
45978     } catch (std::exception& e) {
45979       {
45980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45981       };
45982     } catch (Dali::DaliException e) {
45983       {
45984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45985       };
45986     } catch (...) {
45987       {
45988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45989       };
45990     }
45991   }
45992
45993   jresult = (unsigned long)result;
45994   return jresult;
45995 }
45996
45997
45998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
45999   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46000   std::vector< Dali::TouchPoint >::size_type arg2 ;
46001
46002   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46003   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
46004   {
46005     try {
46006       (arg1)->reserve(arg2);
46007     } catch (std::out_of_range& e) {
46008       {
46009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46010       };
46011     } catch (std::exception& e) {
46012       {
46013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46014       };
46015     } catch (Dali::DaliException e) {
46016       {
46017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46018       };
46019     } catch (...) {
46020       {
46021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46022       };
46023     }
46024   }
46025
46026 }
46027
46028
46029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
46030   void * jresult ;
46031   std::vector< Dali::TouchPoint > *result = 0 ;
46032
46033   {
46034     try {
46035       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
46036     } catch (std::out_of_range& e) {
46037       {
46038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46039       };
46040     } catch (std::exception& e) {
46041       {
46042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46043       };
46044     } catch (Dali::DaliException e) {
46045       {
46046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46047       };
46048     } catch (...) {
46049       {
46050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46051       };
46052     }
46053   }
46054
46055   jresult = (void *)result;
46056   return jresult;
46057 }
46058
46059
46060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
46061   void * jresult ;
46062   std::vector< Dali::TouchPoint > *arg1 = 0 ;
46063   std::vector< Dali::TouchPoint > *result = 0 ;
46064
46065   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46066   if (!arg1) {
46067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46068     return 0;
46069   }
46070   {
46071     try {
46072       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
46073     } catch (std::out_of_range& e) {
46074       {
46075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46076       };
46077     } catch (std::exception& e) {
46078       {
46079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46080       };
46081     } catch (Dali::DaliException e) {
46082       {
46083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46084       };
46085     } catch (...) {
46086       {
46087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46088       };
46089     }
46090   }
46091
46092   jresult = (void *)result;
46093   return jresult;
46094 }
46095
46096
46097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
46098   void * jresult ;
46099   int arg1 ;
46100   std::vector< Dali::TouchPoint > *result = 0 ;
46101
46102   arg1 = (int)jarg1;
46103   {
46104     try {
46105       try {
46106         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
46107       }
46108       catch(std::out_of_range &_e) {
46109         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46110         return 0;
46111       }
46112
46113     } catch (std::out_of_range& e) {
46114       {
46115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46116       };
46117     } catch (std::exception& e) {
46118       {
46119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46120       };
46121     } catch (Dali::DaliException e) {
46122       {
46123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46124       };
46125     } catch (...) {
46126       {
46127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46128       };
46129     }
46130   }
46131
46132   jresult = (void *)result;
46133   return jresult;
46134 }
46135
46136
46137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
46138   void * jresult ;
46139   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46140   int arg2 ;
46141   SwigValueWrapper< Dali::TouchPoint > result;
46142
46143   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46144   arg2 = (int)jarg2;
46145   {
46146     try {
46147       try {
46148         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
46149       }
46150       catch(std::out_of_range &_e) {
46151         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46152         return 0;
46153       }
46154
46155     } catch (std::out_of_range& e) {
46156       {
46157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46158       };
46159     } catch (std::exception& e) {
46160       {
46161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46162       };
46163     } catch (Dali::DaliException e) {
46164       {
46165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46166       };
46167     } catch (...) {
46168       {
46169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46170       };
46171     }
46172   }
46173
46174   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
46175   return jresult;
46176 }
46177
46178
46179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
46180   void * jresult ;
46181   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46182   int arg2 ;
46183   Dali::TouchPoint *result = 0 ;
46184
46185   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46186   arg2 = (int)jarg2;
46187   {
46188     try {
46189       try {
46190         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
46191       }
46192       catch(std::out_of_range &_e) {
46193         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46194         return 0;
46195       }
46196
46197     } catch (std::out_of_range& e) {
46198       {
46199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46200       };
46201     } catch (std::exception& e) {
46202       {
46203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46204       };
46205     } catch (Dali::DaliException e) {
46206       {
46207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46208       };
46209     } catch (...) {
46210       {
46211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46212       };
46213     }
46214   }
46215
46216   jresult = (void *)result;
46217   return jresult;
46218 }
46219
46220
46221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
46222   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46223   int arg2 ;
46224   Dali::TouchPoint *arg3 = 0 ;
46225
46226   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46227   arg2 = (int)jarg2;
46228   arg3 = (Dali::TouchPoint *)jarg3;
46229   if (!arg3) {
46230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46231     return ;
46232   }
46233   {
46234     try {
46235       try {
46236         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46237       }
46238       catch(std::out_of_range &_e) {
46239         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46240         return ;
46241       }
46242
46243     } catch (std::out_of_range& e) {
46244       {
46245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46246       };
46247     } catch (std::exception& e) {
46248       {
46249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46250       };
46251     } catch (Dali::DaliException e) {
46252       {
46253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46254       };
46255     } catch (...) {
46256       {
46257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46258       };
46259     }
46260   }
46261
46262 }
46263
46264
46265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
46266   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46267   std::vector< Dali::TouchPoint > *arg2 = 0 ;
46268
46269   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46270   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
46271   if (!arg2) {
46272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46273     return ;
46274   }
46275   {
46276     try {
46277       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
46278     } catch (std::out_of_range& e) {
46279       {
46280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46281       };
46282     } catch (std::exception& e) {
46283       {
46284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46285       };
46286     } catch (Dali::DaliException e) {
46287       {
46288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46289       };
46290     } catch (...) {
46291       {
46292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46293       };
46294     }
46295   }
46296
46297 }
46298
46299
46300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
46301   void * jresult ;
46302   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46303   int arg2 ;
46304   int arg3 ;
46305   std::vector< Dali::TouchPoint > *result = 0 ;
46306
46307   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46308   arg2 = (int)jarg2;
46309   arg3 = (int)jarg3;
46310   {
46311     try {
46312       try {
46313         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
46314       }
46315       catch(std::out_of_range &_e) {
46316         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46317         return 0;
46318       }
46319       catch(std::invalid_argument &_e) {
46320         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46321         return 0;
46322       }
46323
46324     } catch (std::out_of_range& e) {
46325       {
46326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46327       };
46328     } catch (std::exception& e) {
46329       {
46330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46331       };
46332     } catch (Dali::DaliException e) {
46333       {
46334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46335       };
46336     } catch (...) {
46337       {
46338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46339       };
46340     }
46341   }
46342
46343   jresult = (void *)result;
46344   return jresult;
46345 }
46346
46347
46348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
46349   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46350   int arg2 ;
46351   Dali::TouchPoint *arg3 = 0 ;
46352
46353   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46354   arg2 = (int)jarg2;
46355   arg3 = (Dali::TouchPoint *)jarg3;
46356   if (!arg3) {
46357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46358     return ;
46359   }
46360   {
46361     try {
46362       try {
46363         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46364       }
46365       catch(std::out_of_range &_e) {
46366         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46367         return ;
46368       }
46369
46370     } catch (std::out_of_range& e) {
46371       {
46372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46373       };
46374     } catch (std::exception& e) {
46375       {
46376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46377       };
46378     } catch (Dali::DaliException e) {
46379       {
46380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46381       };
46382     } catch (...) {
46383       {
46384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46385       };
46386     }
46387   }
46388
46389 }
46390
46391
46392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
46393   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46394   int arg2 ;
46395   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46396
46397   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46398   arg2 = (int)jarg2;
46399   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46400   if (!arg3) {
46401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46402     return ;
46403   }
46404   {
46405     try {
46406       try {
46407         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46408       }
46409       catch(std::out_of_range &_e) {
46410         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46411         return ;
46412       }
46413
46414     } catch (std::out_of_range& e) {
46415       {
46416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46417       };
46418     } catch (std::exception& e) {
46419       {
46420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46421       };
46422     } catch (Dali::DaliException e) {
46423       {
46424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46425       };
46426     } catch (...) {
46427       {
46428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46429       };
46430     }
46431   }
46432
46433 }
46434
46435
46436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
46437   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46438   int arg2 ;
46439
46440   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46441   arg2 = (int)jarg2;
46442   {
46443     try {
46444       try {
46445         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
46446       }
46447       catch(std::out_of_range &_e) {
46448         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46449         return ;
46450       }
46451
46452     } catch (std::out_of_range& e) {
46453       {
46454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46455       };
46456     } catch (std::exception& e) {
46457       {
46458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46459       };
46460     } catch (Dali::DaliException e) {
46461       {
46462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46463       };
46464     } catch (...) {
46465       {
46466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46467       };
46468     }
46469   }
46470
46471 }
46472
46473
46474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
46475   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46476   int arg2 ;
46477   int arg3 ;
46478
46479   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46480   arg2 = (int)jarg2;
46481   arg3 = (int)jarg3;
46482   {
46483     try {
46484       try {
46485         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
46486       }
46487       catch(std::out_of_range &_e) {
46488         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46489         return ;
46490       }
46491       catch(std::invalid_argument &_e) {
46492         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46493         return ;
46494       }
46495
46496     } catch (std::out_of_range& e) {
46497       {
46498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46499       };
46500     } catch (std::exception& e) {
46501       {
46502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46503       };
46504     } catch (Dali::DaliException e) {
46505       {
46506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46507       };
46508     } catch (...) {
46509       {
46510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46511       };
46512     }
46513   }
46514
46515 }
46516
46517
46518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
46519   void * jresult ;
46520   Dali::TouchPoint *arg1 = 0 ;
46521   int arg2 ;
46522   std::vector< Dali::TouchPoint > *result = 0 ;
46523
46524   arg1 = (Dali::TouchPoint *)jarg1;
46525   if (!arg1) {
46526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46527     return 0;
46528   }
46529   arg2 = (int)jarg2;
46530   {
46531     try {
46532       try {
46533         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
46534       }
46535       catch(std::out_of_range &_e) {
46536         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46537         return 0;
46538       }
46539
46540     } catch (std::out_of_range& e) {
46541       {
46542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46543       };
46544     } catch (std::exception& e) {
46545       {
46546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46547       };
46548     } catch (Dali::DaliException e) {
46549       {
46550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46551       };
46552     } catch (...) {
46553       {
46554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46555       };
46556     }
46557   }
46558
46559   jresult = (void *)result;
46560   return jresult;
46561 }
46562
46563
46564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
46565   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46566
46567   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46568   {
46569     try {
46570       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
46571     } catch (std::out_of_range& e) {
46572       {
46573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46574       };
46575     } catch (std::exception& e) {
46576       {
46577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46578       };
46579     } catch (Dali::DaliException e) {
46580       {
46581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46582       };
46583     } catch (...) {
46584       {
46585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46586       };
46587     }
46588   }
46589
46590 }
46591
46592
46593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
46594   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46595   int arg2 ;
46596   int arg3 ;
46597
46598   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46599   arg2 = (int)jarg2;
46600   arg3 = (int)jarg3;
46601   {
46602     try {
46603       try {
46604         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
46605       }
46606       catch(std::out_of_range &_e) {
46607         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46608         return ;
46609       }
46610       catch(std::invalid_argument &_e) {
46611         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46612         return ;
46613       }
46614
46615     } catch (std::out_of_range& e) {
46616       {
46617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46618       };
46619     } catch (std::exception& e) {
46620       {
46621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46622       };
46623     } catch (Dali::DaliException e) {
46624       {
46625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46626       };
46627     } catch (...) {
46628       {
46629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46630       };
46631     }
46632   }
46633
46634 }
46635
46636
46637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
46638   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46639   int arg2 ;
46640   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46641
46642   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46643   arg2 = (int)jarg2;
46644   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46645   if (!arg3) {
46646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46647     return ;
46648   }
46649   {
46650     try {
46651       try {
46652         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46653       }
46654       catch(std::out_of_range &_e) {
46655         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46656         return ;
46657       }
46658
46659     } catch (std::out_of_range& e) {
46660       {
46661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46662       };
46663     } catch (std::exception& e) {
46664       {
46665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46666       };
46667     } catch (Dali::DaliException e) {
46668       {
46669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46670       };
46671     } catch (...) {
46672       {
46673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46674       };
46675     }
46676   }
46677
46678 }
46679
46680
46681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
46682   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46683
46684   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46685   {
46686     try {
46687       delete arg1;
46688     } catch (std::out_of_range& e) {
46689       {
46690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46691       };
46692     } catch (std::exception& e) {
46693       {
46694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46695       };
46696     } catch (Dali::DaliException e) {
46697       {
46698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46699       };
46700     } catch (...) {
46701       {
46702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46703       };
46704     }
46705   }
46706
46707 }
46708
46709
46710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
46711   void * jresult ;
46712   Dali::Rect< int > *result = 0 ;
46713
46714   {
46715     try {
46716       result = (Dali::Rect< int > *)new Dali::Rect< int >();
46717     } catch (std::out_of_range& e) {
46718       {
46719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46720       };
46721     } catch (std::exception& e) {
46722       {
46723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46724       };
46725     } catch (Dali::DaliException e) {
46726       {
46727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46728       };
46729     } catch (...) {
46730       {
46731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46732       };
46733     }
46734   }
46735
46736   jresult = (void *)result;
46737   return jresult;
46738 }
46739
46740
46741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
46742   void * jresult ;
46743   int arg1 ;
46744   int arg2 ;
46745   int arg3 ;
46746   int arg4 ;
46747   Dali::Rect< int > *result = 0 ;
46748
46749   arg1 = (int)jarg1;
46750   arg2 = (int)jarg2;
46751   arg3 = (int)jarg3;
46752   arg4 = (int)jarg4;
46753   {
46754     try {
46755       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
46756     } catch (std::out_of_range& e) {
46757       {
46758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46759       };
46760     } catch (std::exception& e) {
46761       {
46762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46763       };
46764     } catch (Dali::DaliException e) {
46765       {
46766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46767       };
46768     } catch (...) {
46769       {
46770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46771       };
46772     }
46773   }
46774
46775   jresult = (void *)result;
46776   return jresult;
46777 }
46778
46779
46780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
46781   void * jresult ;
46782   Dali::Rect< int > *arg1 = 0 ;
46783   Dali::Rect< int > *result = 0 ;
46784
46785   arg1 = (Dali::Rect< int > *)jarg1;
46786   if (!arg1) {
46787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46788     return 0;
46789   }
46790   {
46791     try {
46792       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
46793     } catch (std::out_of_range& e) {
46794       {
46795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46796       };
46797     } catch (std::exception& e) {
46798       {
46799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46800       };
46801     } catch (Dali::DaliException e) {
46802       {
46803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46804       };
46805     } catch (...) {
46806       {
46807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46808       };
46809     }
46810   }
46811
46812   jresult = (void *)result;
46813   return jresult;
46814 }
46815
46816
46817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
46818   void * jresult ;
46819   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46820   Dali::Rect< int > *arg2 = 0 ;
46821   Dali::Rect< int > *result = 0 ;
46822
46823   arg1 = (Dali::Rect< int > *)jarg1;
46824   arg2 = (Dali::Rect< int > *)jarg2;
46825   if (!arg2) {
46826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46827     return 0;
46828   }
46829   {
46830     try {
46831       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
46832     } catch (std::out_of_range& e) {
46833       {
46834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46835       };
46836     } catch (std::exception& e) {
46837       {
46838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46839       };
46840     } catch (Dali::DaliException e) {
46841       {
46842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46843       };
46844     } catch (...) {
46845       {
46846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46847       };
46848     }
46849   }
46850
46851   jresult = (void *)result;
46852   return jresult;
46853 }
46854
46855
46856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
46857   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46858   int arg2 ;
46859   int arg3 ;
46860   int arg4 ;
46861   int arg5 ;
46862
46863   arg1 = (Dali::Rect< int > *)jarg1;
46864   arg2 = (int)jarg2;
46865   arg3 = (int)jarg3;
46866   arg4 = (int)jarg4;
46867   arg5 = (int)jarg5;
46868   {
46869     try {
46870       (arg1)->Set(arg2,arg3,arg4,arg5);
46871     } catch (std::out_of_range& e) {
46872       {
46873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46874       };
46875     } catch (std::exception& e) {
46876       {
46877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46878       };
46879     } catch (Dali::DaliException e) {
46880       {
46881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46882       };
46883     } catch (...) {
46884       {
46885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46886       };
46887     }
46888   }
46889
46890 }
46891
46892
46893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
46894   unsigned int jresult ;
46895   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46896   bool result;
46897
46898   arg1 = (Dali::Rect< int > *)jarg1;
46899   {
46900     try {
46901       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
46902     } catch (std::out_of_range& e) {
46903       {
46904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46905       };
46906     } catch (std::exception& e) {
46907       {
46908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46909       };
46910     } catch (Dali::DaliException e) {
46911       {
46912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46913       };
46914     } catch (...) {
46915       {
46916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46917       };
46918     }
46919   }
46920
46921   jresult = result;
46922   return jresult;
46923 }
46924
46925
46926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
46927   int jresult ;
46928   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46929   int result;
46930
46931   arg1 = (Dali::Rect< int > *)jarg1;
46932   {
46933     try {
46934       result = (int)((Dali::Rect< int > const *)arg1)->Left();
46935     } catch (std::out_of_range& e) {
46936       {
46937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46938       };
46939     } catch (std::exception& e) {
46940       {
46941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46942       };
46943     } catch (Dali::DaliException e) {
46944       {
46945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46946       };
46947     } catch (...) {
46948       {
46949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46950       };
46951     }
46952   }
46953
46954   jresult = result;
46955   return jresult;
46956 }
46957
46958
46959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
46960   int jresult ;
46961   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46962   int result;
46963
46964   arg1 = (Dali::Rect< int > *)jarg1;
46965   {
46966     try {
46967       result = (int)((Dali::Rect< int > const *)arg1)->Right();
46968     } catch (std::out_of_range& e) {
46969       {
46970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46971       };
46972     } catch (std::exception& e) {
46973       {
46974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46975       };
46976     } catch (Dali::DaliException e) {
46977       {
46978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46979       };
46980     } catch (...) {
46981       {
46982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46983       };
46984     }
46985   }
46986
46987   jresult = result;
46988   return jresult;
46989 }
46990
46991
46992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
46993   int jresult ;
46994   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46995   int result;
46996
46997   arg1 = (Dali::Rect< int > *)jarg1;
46998   {
46999     try {
47000       result = (int)((Dali::Rect< int > const *)arg1)->Top();
47001     } catch (std::out_of_range& e) {
47002       {
47003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47004       };
47005     } catch (std::exception& e) {
47006       {
47007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47008       };
47009     } catch (Dali::DaliException e) {
47010       {
47011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47012       };
47013     } catch (...) {
47014       {
47015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47016       };
47017     }
47018   }
47019
47020   jresult = result;
47021   return jresult;
47022 }
47023
47024
47025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
47026   int jresult ;
47027   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47028   int result;
47029
47030   arg1 = (Dali::Rect< int > *)jarg1;
47031   {
47032     try {
47033       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
47034     } catch (std::out_of_range& e) {
47035       {
47036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47037       };
47038     } catch (std::exception& e) {
47039       {
47040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47041       };
47042     } catch (Dali::DaliException e) {
47043       {
47044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47045       };
47046     } catch (...) {
47047       {
47048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47049       };
47050     }
47051   }
47052
47053   jresult = result;
47054   return jresult;
47055 }
47056
47057
47058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
47059   int jresult ;
47060   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47061   int result;
47062
47063   arg1 = (Dali::Rect< int > *)jarg1;
47064   {
47065     try {
47066       result = (int)((Dali::Rect< int > const *)arg1)->Area();
47067     } catch (std::out_of_range& e) {
47068       {
47069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47070       };
47071     } catch (std::exception& e) {
47072       {
47073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47074       };
47075     } catch (Dali::DaliException e) {
47076       {
47077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47078       };
47079     } catch (...) {
47080       {
47081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47082       };
47083     }
47084   }
47085
47086   jresult = result;
47087   return jresult;
47088 }
47089
47090
47091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
47092   unsigned int jresult ;
47093   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47094   Dali::Rect< int > *arg2 = 0 ;
47095   bool result;
47096
47097   arg1 = (Dali::Rect< int > *)jarg1;
47098   arg2 = (Dali::Rect< int > *)jarg2;
47099   if (!arg2) {
47100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47101     return 0;
47102   }
47103   {
47104     try {
47105       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
47106     } catch (std::out_of_range& e) {
47107       {
47108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47109       };
47110     } catch (std::exception& e) {
47111       {
47112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47113       };
47114     } catch (Dali::DaliException e) {
47115       {
47116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47117       };
47118     } catch (...) {
47119       {
47120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47121       };
47122     }
47123   }
47124
47125   jresult = result;
47126   return jresult;
47127 }
47128
47129
47130 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
47131   unsigned int jresult ;
47132   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47133   Dali::Rect< int > *arg2 = 0 ;
47134   bool result;
47135
47136   arg1 = (Dali::Rect< int > *)jarg1;
47137   arg2 = (Dali::Rect< int > *)jarg2;
47138   if (!arg2) {
47139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47140     return 0;
47141   }
47142   {
47143     try {
47144       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
47145     } catch (std::out_of_range& e) {
47146       {
47147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47148       };
47149     } catch (std::exception& e) {
47150       {
47151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47152       };
47153     } catch (Dali::DaliException e) {
47154       {
47155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47156       };
47157     } catch (...) {
47158       {
47159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47160       };
47161     }
47162   }
47163
47164   jresult = result;
47165   return jresult;
47166 }
47167
47168
47169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
47170   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47171   int arg2 ;
47172
47173   arg1 = (Dali::Rect< int > *)jarg1;
47174   arg2 = (int)jarg2;
47175   if (arg1) (arg1)->x = arg2;
47176 }
47177
47178
47179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
47180   int jresult ;
47181   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47182   int result;
47183
47184   arg1 = (Dali::Rect< int > *)jarg1;
47185   result = (int) ((arg1)->x);
47186   jresult = result;
47187   return jresult;
47188 }
47189
47190
47191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
47192   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47193   int arg2 ;
47194
47195   arg1 = (Dali::Rect< int > *)jarg1;
47196   arg2 = (int)jarg2;
47197   if (arg1) (arg1)->left = arg2;
47198 }
47199
47200
47201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
47202   int jresult ;
47203   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47204   int result;
47205
47206   arg1 = (Dali::Rect< int > *)jarg1;
47207   result = (int) ((arg1)->left);
47208   jresult = result;
47209   return jresult;
47210 }
47211
47212
47213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
47214   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47215   int arg2 ;
47216
47217   arg1 = (Dali::Rect< int > *)jarg1;
47218   arg2 = (int)jarg2;
47219   if (arg1) (arg1)->y = arg2;
47220 }
47221
47222
47223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
47224   int jresult ;
47225   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47226   int result;
47227
47228   arg1 = (Dali::Rect< int > *)jarg1;
47229   result = (int) ((arg1)->y);
47230   jresult = result;
47231   return jresult;
47232 }
47233
47234
47235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
47236   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47237   int arg2 ;
47238
47239   arg1 = (Dali::Rect< int > *)jarg1;
47240   arg2 = (int)jarg2;
47241   if (arg1) (arg1)->right = arg2;
47242 }
47243
47244
47245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
47246   int jresult ;
47247   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47248   int result;
47249
47250   arg1 = (Dali::Rect< int > *)jarg1;
47251   result = (int) ((arg1)->right);
47252   jresult = result;
47253   return jresult;
47254 }
47255
47256
47257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
47258   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47259   int arg2 ;
47260
47261   arg1 = (Dali::Rect< int > *)jarg1;
47262   arg2 = (int)jarg2;
47263   if (arg1) (arg1)->width = arg2;
47264 }
47265
47266
47267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
47268   int jresult ;
47269   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47270   int result;
47271
47272   arg1 = (Dali::Rect< int > *)jarg1;
47273   result = (int) ((arg1)->width);
47274   jresult = result;
47275   return jresult;
47276 }
47277
47278
47279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
47280   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47281   int arg2 ;
47282
47283   arg1 = (Dali::Rect< int > *)jarg1;
47284   arg2 = (int)jarg2;
47285   if (arg1) (arg1)->bottom = arg2;
47286 }
47287
47288
47289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
47290   int jresult ;
47291   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47292   int result;
47293
47294   arg1 = (Dali::Rect< int > *)jarg1;
47295   result = (int) ((arg1)->bottom);
47296   jresult = result;
47297   return jresult;
47298 }
47299
47300
47301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
47302   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47303   int arg2 ;
47304
47305   arg1 = (Dali::Rect< int > *)jarg1;
47306   arg2 = (int)jarg2;
47307   if (arg1) (arg1)->height = arg2;
47308 }
47309
47310
47311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
47312   int jresult ;
47313   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47314   int result;
47315
47316   arg1 = (Dali::Rect< int > *)jarg1;
47317   result = (int) ((arg1)->height);
47318   jresult = result;
47319   return jresult;
47320 }
47321
47322
47323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
47324   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47325   int arg2 ;
47326
47327   arg1 = (Dali::Rect< int > *)jarg1;
47328   arg2 = (int)jarg2;
47329   if (arg1) (arg1)->top = arg2;
47330 }
47331
47332
47333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
47334   int jresult ;
47335   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47336   int result;
47337
47338   arg1 = (Dali::Rect< int > *)jarg1;
47339   result = (int) ((arg1)->top);
47340   jresult = result;
47341   return jresult;
47342 }
47343
47344
47345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
47346   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47347
47348   arg1 = (Dali::Rect< int > *)jarg1;
47349   {
47350     try {
47351       delete arg1;
47352     } catch (std::out_of_range& e) {
47353       {
47354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47355       };
47356     } catch (std::exception& e) {
47357       {
47358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47359       };
47360     } catch (Dali::DaliException e) {
47361       {
47362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47363       };
47364     } catch (...) {
47365       {
47366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47367       };
47368     }
47369   }
47370
47371 }
47372
47373
47374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
47375   void * jresult ;
47376   Dali::Rect< float > *result = 0 ;
47377
47378   {
47379     try {
47380       result = (Dali::Rect< float > *)new Dali::Rect< float >();
47381     } catch (std::out_of_range& e) {
47382       {
47383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47384       };
47385     } catch (std::exception& e) {
47386       {
47387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47388       };
47389     } catch (Dali::DaliException e) {
47390       {
47391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47392       };
47393     } catch (...) {
47394       {
47395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47396       };
47397     }
47398   }
47399
47400   jresult = (void *)result;
47401   return jresult;
47402 }
47403
47404
47405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
47406   void * jresult ;
47407   float arg1 ;
47408   float arg2 ;
47409   float arg3 ;
47410   float arg4 ;
47411   Dali::Rect< float > *result = 0 ;
47412
47413   arg1 = (float)jarg1;
47414   arg2 = (float)jarg2;
47415   arg3 = (float)jarg4;
47416   arg4 = (float)jarg3;
47417   {
47418     try {
47419       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
47420     } catch (std::out_of_range& e) {
47421       {
47422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47423       };
47424     } catch (std::exception& e) {
47425       {
47426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47427       };
47428     } catch (Dali::DaliException e) {
47429       {
47430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47431       };
47432     } catch (...) {
47433       {
47434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47435       };
47436     }
47437   }
47438
47439   jresult = (void *)result;
47440   return jresult;
47441 }
47442
47443
47444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
47445   void * jresult ;
47446   Dali::Rect< float > *arg1 = 0 ;
47447   Dali::Rect< float > *result = 0 ;
47448
47449   arg1 = (Dali::Rect< float > *)jarg1;
47450   if (!arg1) {
47451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47452     return 0;
47453   }
47454   {
47455     try {
47456       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
47457     } catch (std::out_of_range& e) {
47458       {
47459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47460       };
47461     } catch (std::exception& e) {
47462       {
47463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47464       };
47465     } catch (Dali::DaliException e) {
47466       {
47467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47468       };
47469     } catch (...) {
47470       {
47471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47472       };
47473     }
47474   }
47475
47476   jresult = (void *)result;
47477   return jresult;
47478 }
47479
47480
47481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
47482   void * jresult ;
47483   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47484   Dali::Rect< float > *arg2 = 0 ;
47485   Dali::Rect< float > *result = 0 ;
47486
47487   arg1 = (Dali::Rect< float > *)jarg1;
47488   arg2 = (Dali::Rect< float > *)jarg2;
47489   if (!arg2) {
47490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47491     return 0;
47492   }
47493   {
47494     try {
47495       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
47496     } catch (std::out_of_range& e) {
47497       {
47498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47499       };
47500     } catch (std::exception& e) {
47501       {
47502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47503       };
47504     } catch (Dali::DaliException e) {
47505       {
47506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47507       };
47508     } catch (...) {
47509       {
47510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47511       };
47512     }
47513   }
47514
47515   jresult = (void *)result;
47516   return jresult;
47517 }
47518
47519
47520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
47521   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47522   float arg2 ;
47523   float arg3 ;
47524   float arg4 ;
47525   float arg5 ;
47526
47527   arg1 = (Dali::Rect< float > *)jarg1;
47528   arg2 = (float)jarg2;
47529   arg3 = (float)jarg3;
47530   arg4 = (float)jarg5;
47531   arg5 = (float)jarg4;
47532   {
47533     try {
47534       (arg1)->Set(arg2,arg3,arg4,arg5);
47535     } catch (std::out_of_range& e) {
47536       {
47537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47538       };
47539     } catch (std::exception& e) {
47540       {
47541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47542       };
47543     } catch (Dali::DaliException e) {
47544       {
47545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47546       };
47547     } catch (...) {
47548       {
47549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47550       };
47551     }
47552   }
47553
47554 }
47555
47556
47557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
47558   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47559   float arg2 ;
47560
47561   arg1 = (Dali::Rect< float > *)jarg1;
47562   arg2 = (float)jarg2;
47563   if (arg1) (arg1)->left = arg2;
47564 }
47565
47566
47567 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
47568   float jresult ;
47569   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47570   float result;
47571
47572   arg1 = (Dali::Rect< float > *)jarg1;
47573   result = (float) ((arg1)->left);
47574   jresult = result;
47575   return jresult;
47576 }
47577
47578
47579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
47580   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47581   float arg2 ;
47582
47583   arg1 = (Dali::Rect< float > *)jarg1;
47584   arg2 = (float)jarg2;
47585   if (arg1) (arg1)->left = arg2;
47586 }
47587
47588
47589 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
47590   float jresult ;
47591   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47592   float result;
47593
47594   arg1 = (Dali::Rect< float > *)jarg1;
47595   result = (float) ((arg1)->left);
47596   jresult = result;
47597   return jresult;
47598 }
47599
47600
47601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
47602   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47603   float arg2 ;
47604
47605   arg1 = (Dali::Rect< float > *)jarg1;
47606   arg2 = (float)jarg2;
47607   if (arg1) (arg1)->right = arg2;
47608 }
47609
47610
47611 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
47612   float jresult ;
47613   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47614   float result;
47615
47616   arg1 = (Dali::Rect< float > *)jarg1;
47617   result = (float) ((arg1)->right);
47618   jresult = result;
47619   return jresult;
47620 }
47621
47622
47623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
47624   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47625   float arg2 ;
47626
47627   arg1 = (Dali::Rect< float > *)jarg1;
47628   arg2 = (float)jarg2;
47629   if (arg1) (arg1)->right = arg2;
47630 }
47631
47632
47633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
47634   float jresult ;
47635   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47636   float result;
47637
47638   arg1 = (Dali::Rect< float > *)jarg1;
47639   result = (float) ((arg1)->right);
47640   jresult = result;
47641   return jresult;
47642 }
47643
47644
47645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
47646   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47647   float arg2 ;
47648
47649   arg1 = (Dali::Rect< float > *)jarg1;
47650   arg2 = (float)jarg2;
47651   if (arg1) (arg1)->bottom = arg2;
47652 }
47653
47654
47655 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
47656   float jresult ;
47657   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47658   float result;
47659
47660   arg1 = (Dali::Rect< float > *)jarg1;
47661   result = (float) ((arg1)->bottom);
47662   jresult = result;
47663   return jresult;
47664 }
47665
47666
47667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
47668   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47669   float arg2 ;
47670
47671   arg1 = (Dali::Rect< float > *)jarg1;
47672   arg2 = (float)jarg2;
47673   if (arg1) (arg1)->top = arg2;
47674 }
47675
47676
47677 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
47678   float jresult ;
47679   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47680   float result;
47681
47682   arg1 = (Dali::Rect< float > *)jarg1;
47683   result = (float) ((arg1)->top);
47684   jresult = result;
47685   return jresult;
47686 }
47687
47688
47689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
47690   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47691
47692   arg1 = (Dali::Rect< float > *)jarg1;
47693   {
47694     try {
47695       delete arg1;
47696     } catch (std::out_of_range& e) {
47697       {
47698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47699       };
47700     } catch (std::exception& e) {
47701       {
47702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47703       };
47704     } catch (Dali::DaliException e) {
47705       {
47706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47707       };
47708     } catch (...) {
47709       {
47710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47711       };
47712     }
47713   }
47714
47715 }
47716
47717
47718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
47719   int jresult ;
47720   int result;
47721
47722   result = (int)Dali::Vector< int >::BaseType;
47723   jresult = (int)result;
47724   return jresult;
47725 }
47726
47727
47728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
47729   void * jresult ;
47730   Dali::Vector< int > *result = 0 ;
47731
47732   {
47733     try {
47734       result = (Dali::Vector< int > *)new Dali::Vector< int >();
47735     } catch (std::out_of_range& e) {
47736       {
47737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47738       };
47739     } catch (std::exception& e) {
47740       {
47741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47742       };
47743     } catch (Dali::DaliException e) {
47744       {
47745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47746       };
47747     } catch (...) {
47748       {
47749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47750       };
47751     }
47752   }
47753
47754   jresult = (void *)result;
47755   return jresult;
47756 }
47757
47758
47759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
47760   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47761
47762   arg1 = (Dali::Vector< int > *)jarg1;
47763   {
47764     try {
47765       delete arg1;
47766     } catch (std::out_of_range& e) {
47767       {
47768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47769       };
47770     } catch (std::exception& e) {
47771       {
47772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47773       };
47774     } catch (Dali::DaliException e) {
47775       {
47776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47777       };
47778     } catch (...) {
47779       {
47780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47781       };
47782     }
47783   }
47784
47785 }
47786
47787
47788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
47789   void * jresult ;
47790   Dali::Vector< int > *arg1 = 0 ;
47791   Dali::Vector< int > *result = 0 ;
47792
47793   arg1 = (Dali::Vector< int > *)jarg1;
47794   if (!arg1) {
47795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47796     return 0;
47797   }
47798   {
47799     try {
47800       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
47801     } catch (std::out_of_range& e) {
47802       {
47803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47804       };
47805     } catch (std::exception& e) {
47806       {
47807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47808       };
47809     } catch (Dali::DaliException e) {
47810       {
47811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47812       };
47813     } catch (...) {
47814       {
47815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47816       };
47817     }
47818   }
47819
47820   jresult = (void *)result;
47821   return jresult;
47822 }
47823
47824
47825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
47826   void * jresult ;
47827   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47828   Dali::Vector< int > *arg2 = 0 ;
47829   Dali::Vector< int > *result = 0 ;
47830
47831   arg1 = (Dali::Vector< int > *)jarg1;
47832   arg2 = (Dali::Vector< int > *)jarg2;
47833   if (!arg2) {
47834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47835     return 0;
47836   }
47837   {
47838     try {
47839       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
47840     } catch (std::out_of_range& e) {
47841       {
47842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47843       };
47844     } catch (std::exception& e) {
47845       {
47846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47847       };
47848     } catch (Dali::DaliException e) {
47849       {
47850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47851       };
47852     } catch (...) {
47853       {
47854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47855       };
47856     }
47857   }
47858
47859   jresult = (void *)result;
47860   return jresult;
47861 }
47862
47863
47864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
47865   void * jresult ;
47866   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47867   Dali::Vector< int >::Iterator result;
47868
47869   arg1 = (Dali::Vector< int > *)jarg1;
47870   {
47871     try {
47872       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
47873     } catch (std::out_of_range& e) {
47874       {
47875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47876       };
47877     } catch (std::exception& e) {
47878       {
47879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47880       };
47881     } catch (Dali::DaliException e) {
47882       {
47883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47884       };
47885     } catch (...) {
47886       {
47887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47888       };
47889     }
47890   }
47891
47892   jresult = (void *)result;
47893   return jresult;
47894 }
47895
47896
47897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
47898   void * jresult ;
47899   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47900   Dali::Vector< int >::Iterator result;
47901
47902   arg1 = (Dali::Vector< int > *)jarg1;
47903   {
47904     try {
47905       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
47906     } catch (std::out_of_range& e) {
47907       {
47908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47909       };
47910     } catch (std::exception& e) {
47911       {
47912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47913       };
47914     } catch (Dali::DaliException e) {
47915       {
47916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47917       };
47918     } catch (...) {
47919       {
47920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47921       };
47922     }
47923   }
47924
47925   jresult = (void *)result;
47926   return jresult;
47927 }
47928
47929
47930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47931   void * jresult ;
47932   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47933   Dali::Vector< int >::SizeType arg2 ;
47934   Dali::Vector< int >::ItemType *result = 0 ;
47935
47936   arg1 = (Dali::Vector< int > *)jarg1;
47937   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47938   {
47939     try {
47940       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
47941     } catch (std::out_of_range& e) {
47942       {
47943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47944       };
47945     } catch (std::exception& e) {
47946       {
47947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47948       };
47949     } catch (Dali::DaliException e) {
47950       {
47951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47952       };
47953     } catch (...) {
47954       {
47955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47956       };
47957     }
47958   }
47959
47960   jresult = (void *)result;
47961   return jresult;
47962 }
47963
47964
47965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
47966   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47967   Dali::Vector< int >::ItemType *arg2 = 0 ;
47968   Dali::Vector< int >::ItemType temp2 ;
47969
47970   arg1 = (Dali::Vector< int > *)jarg1;
47971   temp2 = (Dali::Vector< int >::ItemType)jarg2;
47972   arg2 = &temp2;
47973   {
47974     try {
47975       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
47976     } catch (std::out_of_range& e) {
47977       {
47978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47979       };
47980     } catch (std::exception& e) {
47981       {
47982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47983       };
47984     } catch (Dali::DaliException e) {
47985       {
47986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47987       };
47988     } catch (...) {
47989       {
47990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47991       };
47992     }
47993   }
47994
47995 }
47996
47997
47998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
47999   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48000   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48001   Dali::Vector< int >::ItemType *arg3 = 0 ;
48002   Dali::Vector< int >::ItemType temp3 ;
48003
48004   arg1 = (Dali::Vector< int > *)jarg1;
48005   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48006   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48007   arg3 = &temp3;
48008   {
48009     try {
48010       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48011     } catch (std::out_of_range& e) {
48012       {
48013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48014       };
48015     } catch (std::exception& e) {
48016       {
48017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48018       };
48019     } catch (Dali::DaliException e) {
48020       {
48021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48022       };
48023     } catch (...) {
48024       {
48025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48026       };
48027     }
48028   }
48029
48030 }
48031
48032
48033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48034   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48035   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48036   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48037   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
48038
48039   arg1 = (Dali::Vector< int > *)jarg1;
48040   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48041   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48042   arg4 = (Dali::Vector< int >::Iterator)jarg4;
48043   {
48044     try {
48045       (arg1)->Insert(arg2,arg3,arg4);
48046     } catch (std::out_of_range& e) {
48047       {
48048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48049       };
48050     } catch (std::exception& e) {
48051       {
48052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48053       };
48054     } catch (Dali::DaliException e) {
48055       {
48056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48057       };
48058     } catch (...) {
48059       {
48060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48061       };
48062     }
48063   }
48064
48065 }
48066
48067
48068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
48069   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48070   Dali::Vector< int >::SizeType arg2 ;
48071
48072   arg1 = (Dali::Vector< int > *)jarg1;
48073   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48074   {
48075     try {
48076       (arg1)->Reserve(arg2);
48077     } catch (std::out_of_range& e) {
48078       {
48079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48080       };
48081     } catch (std::exception& e) {
48082       {
48083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48084       };
48085     } catch (Dali::DaliException e) {
48086       {
48087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48088       };
48089     } catch (...) {
48090       {
48091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48092       };
48093     }
48094   }
48095
48096 }
48097
48098
48099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48100   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48101   Dali::Vector< int >::SizeType arg2 ;
48102
48103   arg1 = (Dali::Vector< int > *)jarg1;
48104   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48105   {
48106     try {
48107       (arg1)->Resize(arg2);
48108     } catch (std::out_of_range& e) {
48109       {
48110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48111       };
48112     } catch (std::exception& e) {
48113       {
48114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48115       };
48116     } catch (Dali::DaliException e) {
48117       {
48118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48119       };
48120     } catch (...) {
48121       {
48122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48123       };
48124     }
48125   }
48126
48127 }
48128
48129
48130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
48131   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48132   Dali::Vector< int >::SizeType arg2 ;
48133   Dali::Vector< int >::ItemType *arg3 = 0 ;
48134   Dali::Vector< int >::ItemType temp3 ;
48135
48136   arg1 = (Dali::Vector< int > *)jarg1;
48137   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48138   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48139   arg3 = &temp3;
48140   {
48141     try {
48142       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48143     } catch (std::out_of_range& e) {
48144       {
48145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48146       };
48147     } catch (std::exception& e) {
48148       {
48149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48150       };
48151     } catch (Dali::DaliException e) {
48152       {
48153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48154       };
48155     } catch (...) {
48156       {
48157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48158       };
48159     }
48160   }
48161
48162 }
48163
48164
48165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
48166   void * jresult ;
48167   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48168   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48169   Dali::Vector< int >::Iterator result;
48170
48171   arg1 = (Dali::Vector< int > *)jarg1;
48172   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48173   {
48174     try {
48175       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
48176     } catch (std::out_of_range& e) {
48177       {
48178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48179       };
48180     } catch (std::exception& e) {
48181       {
48182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48183       };
48184     } catch (Dali::DaliException e) {
48185       {
48186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48187       };
48188     } catch (...) {
48189       {
48190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48191       };
48192     }
48193   }
48194
48195   jresult = (void *)result;
48196   return jresult;
48197 }
48198
48199
48200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48201   void * jresult ;
48202   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48203   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48204   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48205   Dali::Vector< int >::Iterator result;
48206
48207   arg1 = (Dali::Vector< int > *)jarg1;
48208   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48209   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48210   {
48211     try {
48212       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
48213     } catch (std::out_of_range& e) {
48214       {
48215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48216       };
48217     } catch (std::exception& e) {
48218       {
48219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48220       };
48221     } catch (Dali::DaliException e) {
48222       {
48223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48224       };
48225     } catch (...) {
48226       {
48227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48228       };
48229     }
48230   }
48231
48232   jresult = (void *)result;
48233   return jresult;
48234 }
48235
48236
48237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
48238   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48239   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48240
48241   arg1 = (Dali::Vector< int > *)jarg1;
48242   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48243   {
48244     try {
48245       (arg1)->Remove(arg2);
48246     } catch (std::out_of_range& e) {
48247       {
48248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48249       };
48250     } catch (std::exception& e) {
48251       {
48252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48253       };
48254     } catch (Dali::DaliException e) {
48255       {
48256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48257       };
48258     } catch (...) {
48259       {
48260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48261       };
48262     }
48263   }
48264
48265 }
48266
48267
48268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
48269   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48270   Dali::Vector< int > *arg2 = 0 ;
48271
48272   arg1 = (Dali::Vector< int > *)jarg1;
48273   arg2 = (Dali::Vector< int > *)jarg2;
48274   if (!arg2) {
48275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
48276     return ;
48277   }
48278   {
48279     try {
48280       (arg1)->Swap(*arg2);
48281     } catch (std::out_of_range& e) {
48282       {
48283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48284       };
48285     } catch (std::exception& e) {
48286       {
48287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48288       };
48289     } catch (Dali::DaliException e) {
48290       {
48291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48292       };
48293     } catch (...) {
48294       {
48295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48296       };
48297     }
48298   }
48299
48300 }
48301
48302
48303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
48304   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48305
48306   arg1 = (Dali::Vector< int > *)jarg1;
48307   {
48308     try {
48309       (arg1)->Clear();
48310     } catch (std::out_of_range& e) {
48311       {
48312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48313       };
48314     } catch (std::exception& e) {
48315       {
48316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48317       };
48318     } catch (Dali::DaliException e) {
48319       {
48320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48321       };
48322     } catch (...) {
48323       {
48324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48325       };
48326     }
48327   }
48328
48329 }
48330
48331
48332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
48333   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48334
48335   arg1 = (Dali::Vector< int > *)jarg1;
48336   {
48337     try {
48338       (arg1)->Release();
48339     } catch (std::out_of_range& e) {
48340       {
48341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48342       };
48343     } catch (std::exception& e) {
48344       {
48345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48346       };
48347     } catch (Dali::DaliException e) {
48348       {
48349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48350       };
48351     } catch (...) {
48352       {
48353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48354       };
48355     }
48356   }
48357
48358 }
48359
48360
48361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
48362   int jresult ;
48363   int result;
48364
48365   result = (int)Dali::Vector< float >::BaseType;
48366   jresult = (int)result;
48367   return jresult;
48368 }
48369
48370
48371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
48372   void * jresult ;
48373   Dali::Vector< float > *result = 0 ;
48374
48375   {
48376     try {
48377       result = (Dali::Vector< float > *)new Dali::Vector< float >();
48378     } catch (std::out_of_range& e) {
48379       {
48380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48381       };
48382     } catch (std::exception& e) {
48383       {
48384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48385       };
48386     } catch (Dali::DaliException e) {
48387       {
48388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48389       };
48390     } catch (...) {
48391       {
48392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48393       };
48394     }
48395   }
48396
48397   jresult = (void *)result;
48398   return jresult;
48399 }
48400
48401
48402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
48403   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48404
48405   arg1 = (Dali::Vector< float > *)jarg1;
48406   {
48407     try {
48408       delete arg1;
48409     } catch (std::out_of_range& e) {
48410       {
48411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48412       };
48413     } catch (std::exception& e) {
48414       {
48415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48416       };
48417     } catch (Dali::DaliException e) {
48418       {
48419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48420       };
48421     } catch (...) {
48422       {
48423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48424       };
48425     }
48426   }
48427
48428 }
48429
48430
48431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
48432   void * jresult ;
48433   Dali::Vector< float > *arg1 = 0 ;
48434   Dali::Vector< float > *result = 0 ;
48435
48436   arg1 = (Dali::Vector< float > *)jarg1;
48437   if (!arg1) {
48438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48439     return 0;
48440   }
48441   {
48442     try {
48443       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
48444     } catch (std::out_of_range& e) {
48445       {
48446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48447       };
48448     } catch (std::exception& e) {
48449       {
48450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48451       };
48452     } catch (Dali::DaliException e) {
48453       {
48454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48455       };
48456     } catch (...) {
48457       {
48458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48459       };
48460     }
48461   }
48462
48463   jresult = (void *)result;
48464   return jresult;
48465 }
48466
48467
48468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
48469   void * jresult ;
48470   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48471   Dali::Vector< float > *arg2 = 0 ;
48472   Dali::Vector< float > *result = 0 ;
48473
48474   arg1 = (Dali::Vector< float > *)jarg1;
48475   arg2 = (Dali::Vector< float > *)jarg2;
48476   if (!arg2) {
48477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48478     return 0;
48479   }
48480   {
48481     try {
48482       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
48483     } catch (std::out_of_range& e) {
48484       {
48485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48486       };
48487     } catch (std::exception& e) {
48488       {
48489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48490       };
48491     } catch (Dali::DaliException e) {
48492       {
48493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48494       };
48495     } catch (...) {
48496       {
48497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48498       };
48499     }
48500   }
48501
48502   jresult = (void *)result;
48503   return jresult;
48504 }
48505
48506
48507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
48508   void * jresult ;
48509   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48510   Dali::Vector< float >::Iterator result;
48511
48512   arg1 = (Dali::Vector< float > *)jarg1;
48513   {
48514     try {
48515       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
48516     } catch (std::out_of_range& e) {
48517       {
48518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48519       };
48520     } catch (std::exception& e) {
48521       {
48522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48523       };
48524     } catch (Dali::DaliException e) {
48525       {
48526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48527       };
48528     } catch (...) {
48529       {
48530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48531       };
48532     }
48533   }
48534
48535   jresult = (void *)result;
48536   return jresult;
48537 }
48538
48539
48540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
48541   void * jresult ;
48542   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48543   Dali::Vector< float >::Iterator result;
48544
48545   arg1 = (Dali::Vector< float > *)jarg1;
48546   {
48547     try {
48548       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
48549     } catch (std::out_of_range& e) {
48550       {
48551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48552       };
48553     } catch (std::exception& e) {
48554       {
48555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48556       };
48557     } catch (Dali::DaliException e) {
48558       {
48559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48560       };
48561     } catch (...) {
48562       {
48563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48564       };
48565     }
48566   }
48567
48568   jresult = (void *)result;
48569   return jresult;
48570 }
48571
48572
48573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48574   void * jresult ;
48575   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48576   Dali::Vector< float >::SizeType arg2 ;
48577   Dali::Vector< float >::ItemType *result = 0 ;
48578
48579   arg1 = (Dali::Vector< float > *)jarg1;
48580   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48581   {
48582     try {
48583       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
48584     } catch (std::out_of_range& e) {
48585       {
48586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48587       };
48588     } catch (std::exception& e) {
48589       {
48590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48591       };
48592     } catch (Dali::DaliException e) {
48593       {
48594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48595       };
48596     } catch (...) {
48597       {
48598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48599       };
48600     }
48601   }
48602
48603   jresult = (void *)result;
48604   return jresult;
48605 }
48606
48607
48608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
48609   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48610   Dali::Vector< float >::ItemType *arg2 = 0 ;
48611   Dali::Vector< float >::ItemType temp2 ;
48612
48613   arg1 = (Dali::Vector< float > *)jarg1;
48614   temp2 = (Dali::Vector< float >::ItemType)jarg2;
48615   arg2 = &temp2;
48616   {
48617     try {
48618       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
48619     } catch (std::out_of_range& e) {
48620       {
48621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48622       };
48623     } catch (std::exception& e) {
48624       {
48625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48626       };
48627     } catch (Dali::DaliException e) {
48628       {
48629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48630       };
48631     } catch (...) {
48632       {
48633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48634       };
48635     }
48636   }
48637
48638 }
48639
48640
48641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
48642   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48643   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48644   Dali::Vector< float >::ItemType *arg3 = 0 ;
48645   Dali::Vector< float >::ItemType temp3 ;
48646
48647   arg1 = (Dali::Vector< float > *)jarg1;
48648   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48649   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48650   arg3 = &temp3;
48651   {
48652     try {
48653       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48654     } catch (std::out_of_range& e) {
48655       {
48656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48657       };
48658     } catch (std::exception& e) {
48659       {
48660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48661       };
48662     } catch (Dali::DaliException e) {
48663       {
48664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48665       };
48666     } catch (...) {
48667       {
48668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48669       };
48670     }
48671   }
48672
48673 }
48674
48675
48676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
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 arg4 = (Dali::Vector< float >::Iterator) 0 ;
48681
48682   arg1 = (Dali::Vector< float > *)jarg1;
48683   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48684   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48685   arg4 = (Dali::Vector< float >::Iterator)jarg4;
48686   {
48687     try {
48688       (arg1)->Insert(arg2,arg3,arg4);
48689     } catch (std::out_of_range& e) {
48690       {
48691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48692       };
48693     } catch (std::exception& e) {
48694       {
48695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48696       };
48697     } catch (Dali::DaliException e) {
48698       {
48699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48700       };
48701     } catch (...) {
48702       {
48703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48704       };
48705     }
48706   }
48707
48708 }
48709
48710
48711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
48712   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48713   Dali::Vector< float >::SizeType arg2 ;
48714
48715   arg1 = (Dali::Vector< float > *)jarg1;
48716   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48717   {
48718     try {
48719       (arg1)->Reserve(arg2);
48720     } catch (std::out_of_range& e) {
48721       {
48722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48723       };
48724     } catch (std::exception& e) {
48725       {
48726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48727       };
48728     } catch (Dali::DaliException e) {
48729       {
48730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48731       };
48732     } catch (...) {
48733       {
48734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48735       };
48736     }
48737   }
48738
48739 }
48740
48741 //// ========================= end of part 2 =============================
48742
48743 //// ========================== start part 3 ===============================
48744
48745
48746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48747   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48748   Dali::Vector< float >::SizeType arg2 ;
48749
48750   arg1 = (Dali::Vector< float > *)jarg1;
48751   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48752   {
48753     try {
48754       (arg1)->Resize(arg2);
48755     } catch (std::out_of_range& e) {
48756       {
48757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48758       };
48759     } catch (std::exception& e) {
48760       {
48761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48762       };
48763     } catch (Dali::DaliException e) {
48764       {
48765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48766       };
48767     } catch (...) {
48768       {
48769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48770       };
48771     }
48772   }
48773
48774 }
48775
48776
48777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
48778   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48779   Dali::Vector< float >::SizeType arg2 ;
48780   Dali::Vector< float >::ItemType *arg3 = 0 ;
48781   Dali::Vector< float >::ItemType temp3 ;
48782
48783   arg1 = (Dali::Vector< float > *)jarg1;
48784   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48785   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48786   arg3 = &temp3;
48787   {
48788     try {
48789       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48790     } catch (std::out_of_range& e) {
48791       {
48792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48793       };
48794     } catch (std::exception& e) {
48795       {
48796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48797       };
48798     } catch (Dali::DaliException e) {
48799       {
48800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48801       };
48802     } catch (...) {
48803       {
48804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48805       };
48806     }
48807   }
48808
48809 }
48810
48811
48812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
48813   void * jresult ;
48814   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48815   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48816   Dali::Vector< float >::Iterator result;
48817
48818   arg1 = (Dali::Vector< float > *)jarg1;
48819   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48820   {
48821     try {
48822       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
48823     } catch (std::out_of_range& e) {
48824       {
48825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48826       };
48827     } catch (std::exception& e) {
48828       {
48829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48830       };
48831     } catch (Dali::DaliException e) {
48832       {
48833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48834       };
48835     } catch (...) {
48836       {
48837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48838       };
48839     }
48840   }
48841
48842   jresult = (void *)result;
48843   return jresult;
48844 }
48845
48846
48847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48848   void * jresult ;
48849   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48850   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48851   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48852   Dali::Vector< float >::Iterator result;
48853
48854   arg1 = (Dali::Vector< float > *)jarg1;
48855   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48856   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48857   {
48858     try {
48859       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
48860     } catch (std::out_of_range& e) {
48861       {
48862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48863       };
48864     } catch (std::exception& e) {
48865       {
48866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48867       };
48868     } catch (Dali::DaliException e) {
48869       {
48870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48871       };
48872     } catch (...) {
48873       {
48874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48875       };
48876     }
48877   }
48878
48879   jresult = (void *)result;
48880   return jresult;
48881 }
48882
48883
48884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
48885   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48886   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48887
48888   arg1 = (Dali::Vector< float > *)jarg1;
48889   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48890   {
48891     try {
48892       (arg1)->Remove(arg2);
48893     } catch (std::out_of_range& e) {
48894       {
48895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48896       };
48897     } catch (std::exception& e) {
48898       {
48899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48900       };
48901     } catch (Dali::DaliException e) {
48902       {
48903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48904       };
48905     } catch (...) {
48906       {
48907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48908       };
48909     }
48910   }
48911
48912 }
48913
48914
48915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
48916   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48917   Dali::Vector< float > *arg2 = 0 ;
48918
48919   arg1 = (Dali::Vector< float > *)jarg1;
48920   arg2 = (Dali::Vector< float > *)jarg2;
48921   if (!arg2) {
48922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
48923     return ;
48924   }
48925   {
48926     try {
48927       (arg1)->Swap(*arg2);
48928     } catch (std::out_of_range& e) {
48929       {
48930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48931       };
48932     } catch (std::exception& e) {
48933       {
48934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48935       };
48936     } catch (Dali::DaliException e) {
48937       {
48938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48939       };
48940     } catch (...) {
48941       {
48942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48943       };
48944     }
48945   }
48946
48947 }
48948
48949
48950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
48951   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48952
48953   arg1 = (Dali::Vector< float > *)jarg1;
48954   {
48955     try {
48956       (arg1)->Clear();
48957     } catch (std::out_of_range& e) {
48958       {
48959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48960       };
48961     } catch (std::exception& e) {
48962       {
48963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48964       };
48965     } catch (Dali::DaliException e) {
48966       {
48967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48968       };
48969     } catch (...) {
48970       {
48971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48972       };
48973     }
48974   }
48975
48976 }
48977
48978
48979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
48980   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48981
48982   arg1 = (Dali::Vector< float > *)jarg1;
48983   {
48984     try {
48985       (arg1)->Release();
48986     } catch (std::out_of_range& e) {
48987       {
48988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48989       };
48990     } catch (std::exception& e) {
48991       {
48992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48993       };
48994     } catch (Dali::DaliException e) {
48995       {
48996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48997       };
48998     } catch (...) {
48999       {
49000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49001       };
49002     }
49003   }
49004
49005 }
49006
49007
49008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
49009   int jresult ;
49010   int result;
49011
49012   result = (int)Dali::Vector< unsigned char >::BaseType;
49013   jresult = (int)result;
49014   return jresult;
49015 }
49016
49017
49018 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
49019   void * jresult ;
49020   Dali::Vector< unsigned char > *result = 0 ;
49021
49022   {
49023     try {
49024       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
49025     } catch (std::out_of_range& e) {
49026       {
49027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49028       };
49029     } catch (std::exception& e) {
49030       {
49031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49032       };
49033     } catch (Dali::DaliException e) {
49034       {
49035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49036       };
49037     } catch (...) {
49038       {
49039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49040       };
49041     }
49042   }
49043
49044   jresult = (void *)result;
49045   return jresult;
49046 }
49047
49048
49049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
49050   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49051
49052   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49053   {
49054     try {
49055       delete arg1;
49056     } catch (std::out_of_range& e) {
49057       {
49058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49059       };
49060     } catch (std::exception& e) {
49061       {
49062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49063       };
49064     } catch (Dali::DaliException e) {
49065       {
49066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49067       };
49068     } catch (...) {
49069       {
49070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49071       };
49072     }
49073   }
49074
49075 }
49076
49077
49078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
49079   void * jresult ;
49080   Dali::Vector< unsigned char > *arg1 = 0 ;
49081   Dali::Vector< unsigned char > *result = 0 ;
49082
49083   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49084   if (!arg1) {
49085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49086     return 0;
49087   }
49088   {
49089     try {
49090       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
49091     } catch (std::out_of_range& e) {
49092       {
49093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49094       };
49095     } catch (std::exception& e) {
49096       {
49097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49098       };
49099     } catch (Dali::DaliException e) {
49100       {
49101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49102       };
49103     } catch (...) {
49104       {
49105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49106       };
49107     }
49108   }
49109
49110   jresult = (void *)result;
49111   return jresult;
49112 }
49113
49114
49115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
49116   void * jresult ;
49117   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49118   Dali::Vector< unsigned char > *arg2 = 0 ;
49119   Dali::Vector< unsigned char > *result = 0 ;
49120
49121   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49122   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49123   if (!arg2) {
49124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49125     return 0;
49126   }
49127   {
49128     try {
49129       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
49130     } catch (std::out_of_range& e) {
49131       {
49132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49133       };
49134     } catch (std::exception& e) {
49135       {
49136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49137       };
49138     } catch (Dali::DaliException e) {
49139       {
49140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49141       };
49142     } catch (...) {
49143       {
49144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49145       };
49146     }
49147   }
49148
49149   jresult = (void *)result;
49150   return jresult;
49151 }
49152
49153
49154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
49155   void * jresult ;
49156   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49157   Dali::Vector< unsigned char >::Iterator result;
49158
49159   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49160   {
49161     try {
49162       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
49163     } catch (std::out_of_range& e) {
49164       {
49165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49166       };
49167     } catch (std::exception& e) {
49168       {
49169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49170       };
49171     } catch (Dali::DaliException e) {
49172       {
49173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49174       };
49175     } catch (...) {
49176       {
49177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49178       };
49179     }
49180   }
49181
49182   jresult = (void *)result;
49183   return jresult;
49184 }
49185
49186
49187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
49188   void * jresult ;
49189   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49190   Dali::Vector< unsigned char >::Iterator result;
49191
49192   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49193   {
49194     try {
49195       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
49196     } catch (std::out_of_range& e) {
49197       {
49198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49199       };
49200     } catch (std::exception& e) {
49201       {
49202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49203       };
49204     } catch (Dali::DaliException e) {
49205       {
49206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49207       };
49208     } catch (...) {
49209       {
49210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49211       };
49212     }
49213   }
49214
49215   jresult = (void *)result;
49216   return jresult;
49217 }
49218
49219
49220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49221   void * jresult ;
49222   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49223   Dali::Vector< unsigned char >::SizeType arg2 ;
49224   Dali::Vector< unsigned char >::ItemType *result = 0 ;
49225
49226   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49227   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49228   {
49229     try {
49230       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
49231     } catch (std::out_of_range& e) {
49232       {
49233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49234       };
49235     } catch (std::exception& e) {
49236       {
49237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49238       };
49239     } catch (Dali::DaliException e) {
49240       {
49241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49242       };
49243     } catch (...) {
49244       {
49245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49246       };
49247     }
49248   }
49249
49250   jresult = (void *)result;
49251   return jresult;
49252 }
49253
49254
49255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
49256   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49257   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
49258   Dali::Vector< unsigned char >::ItemType temp2 ;
49259
49260   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49261   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
49262   arg2 = &temp2;
49263   {
49264     try {
49265       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
49266     } catch (std::out_of_range& e) {
49267       {
49268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49269       };
49270     } catch (std::exception& e) {
49271       {
49272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49273       };
49274     } catch (Dali::DaliException e) {
49275       {
49276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49277       };
49278     } catch (...) {
49279       {
49280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49281       };
49282     }
49283   }
49284
49285 }
49286
49287
49288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
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 >::ItemType *arg3 = 0 ;
49292   Dali::Vector< unsigned char >::ItemType temp3 ;
49293
49294   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49295   arg2 = jarg2;
49296   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49297   arg3 = &temp3;
49298   {
49299     try {
49300       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49301     } catch (std::out_of_range& e) {
49302       {
49303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49304       };
49305     } catch (std::exception& e) {
49306       {
49307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49308       };
49309     } catch (Dali::DaliException e) {
49310       {
49311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49312       };
49313     } catch (...) {
49314       {
49315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49316       };
49317     }
49318   }
49319
49320
49321
49322 }
49323
49324
49325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
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 arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49330
49331   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49332   arg2 = jarg2;
49333   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49334   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
49335   {
49336     try {
49337       (arg1)->Insert(arg2,arg3,arg4);
49338     } catch (std::out_of_range& e) {
49339       {
49340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49341       };
49342     } catch (std::exception& e) {
49343       {
49344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49345       };
49346     } catch (Dali::DaliException e) {
49347       {
49348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49349       };
49350     } catch (...) {
49351       {
49352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49353       };
49354     }
49355   }
49356
49357
49358
49359 }
49360
49361
49362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
49363   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49364   Dali::Vector< unsigned char >::SizeType arg2 ;
49365
49366   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49367   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49368   {
49369     try {
49370       (arg1)->Reserve(arg2);
49371     } catch (std::out_of_range& e) {
49372       {
49373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49374       };
49375     } catch (std::exception& e) {
49376       {
49377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49378       };
49379     } catch (Dali::DaliException e) {
49380       {
49381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49382       };
49383     } catch (...) {
49384       {
49385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49386       };
49387     }
49388   }
49389
49390 }
49391
49392
49393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49394   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49395   Dali::Vector< unsigned char >::SizeType arg2 ;
49396
49397   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49398   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49399   {
49400     try {
49401       (arg1)->Resize(arg2);
49402     } catch (std::out_of_range& e) {
49403       {
49404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49405       };
49406     } catch (std::exception& e) {
49407       {
49408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49409       };
49410     } catch (Dali::DaliException e) {
49411       {
49412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49413       };
49414     } catch (...) {
49415       {
49416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49417       };
49418     }
49419   }
49420
49421 }
49422
49423
49424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
49425   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49426   Dali::Vector< unsigned char >::SizeType arg2 ;
49427   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49428   Dali::Vector< unsigned char >::ItemType temp3 ;
49429
49430   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49431   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49432   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49433   arg3 = &temp3;
49434   {
49435     try {
49436       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49437     } catch (std::out_of_range& e) {
49438       {
49439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49440       };
49441     } catch (std::exception& e) {
49442       {
49443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49444       };
49445     } catch (Dali::DaliException e) {
49446       {
49447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49448       };
49449     } catch (...) {
49450       {
49451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49452       };
49453     }
49454   }
49455
49456 }
49457
49458
49459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
49460   void * jresult ;
49461   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49462   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49463   Dali::Vector< unsigned char >::Iterator result;
49464
49465   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49466   arg2 = jarg2;
49467   {
49468     try {
49469       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
49470     } catch (std::out_of_range& e) {
49471       {
49472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49473       };
49474     } catch (std::exception& e) {
49475       {
49476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49477       };
49478     } catch (Dali::DaliException e) {
49479       {
49480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49481       };
49482     } catch (...) {
49483       {
49484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49485       };
49486     }
49487   }
49488
49489   jresult = (void *)result;
49490
49491
49492   return jresult;
49493 }
49494
49495
49496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
49497   void * jresult ;
49498   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49499   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49500   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49501   Dali::Vector< unsigned char >::Iterator result;
49502
49503   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49504   arg2 = jarg2;
49505   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49506   {
49507     try {
49508       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
49509     } catch (std::out_of_range& e) {
49510       {
49511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49512       };
49513     } catch (std::exception& e) {
49514       {
49515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49516       };
49517     } catch (Dali::DaliException e) {
49518       {
49519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49520       };
49521     } catch (...) {
49522       {
49523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49524       };
49525     }
49526   }
49527
49528   jresult = (void *)result;
49529
49530
49531   return jresult;
49532 }
49533
49534
49535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
49536   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49537   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49538
49539   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49540   arg2 = jarg2;
49541   {
49542     try {
49543       (arg1)->Remove(arg2);
49544     } catch (std::out_of_range& e) {
49545       {
49546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49547       };
49548     } catch (std::exception& e) {
49549       {
49550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49551       };
49552     } catch (Dali::DaliException e) {
49553       {
49554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49555       };
49556     } catch (...) {
49557       {
49558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49559       };
49560     }
49561   }
49562
49563
49564
49565 }
49566
49567
49568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
49569   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49570   Dali::Vector< unsigned char > *arg2 = 0 ;
49571
49572   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49573   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49574   if (!arg2) {
49575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
49576     return ;
49577   }
49578   {
49579     try {
49580       (arg1)->Swap(*arg2);
49581     } catch (std::out_of_range& e) {
49582       {
49583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49584       };
49585     } catch (std::exception& e) {
49586       {
49587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49588       };
49589     } catch (Dali::DaliException e) {
49590       {
49591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49592       };
49593     } catch (...) {
49594       {
49595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49596       };
49597     }
49598   }
49599
49600 }
49601
49602
49603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
49604   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49605
49606   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49607   {
49608     try {
49609       (arg1)->Clear();
49610     } catch (std::out_of_range& e) {
49611       {
49612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49613       };
49614     } catch (std::exception& e) {
49615       {
49616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49617       };
49618     } catch (Dali::DaliException e) {
49619       {
49620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49621       };
49622     } catch (...) {
49623       {
49624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49625       };
49626     }
49627   }
49628
49629 }
49630
49631
49632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
49633   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49634
49635   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49636   {
49637     try {
49638       (arg1)->Release();
49639     } catch (std::out_of_range& e) {
49640       {
49641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49642       };
49643     } catch (std::exception& e) {
49644       {
49645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49646       };
49647     } catch (Dali::DaliException e) {
49648       {
49649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49650       };
49651     } catch (...) {
49652       {
49653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49654       };
49655     }
49656   }
49657
49658 }
49659
49660
49661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
49662   int jresult ;
49663   int result;
49664
49665   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
49666   jresult = (int)result;
49667   return jresult;
49668 }
49669
49670
49671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
49672   void * jresult ;
49673   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49674
49675   {
49676     try {
49677       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
49678     } catch (std::out_of_range& e) {
49679       {
49680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49681       };
49682     } catch (std::exception& e) {
49683       {
49684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49685       };
49686     } catch (Dali::DaliException e) {
49687       {
49688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49689       };
49690     } catch (...) {
49691       {
49692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49693       };
49694     }
49695   }
49696
49697   jresult = (void *)result;
49698   return jresult;
49699 }
49700
49701
49702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
49703   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49704
49705   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49706   {
49707     try {
49708       delete arg1;
49709     } catch (std::out_of_range& e) {
49710       {
49711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49712       };
49713     } catch (std::exception& e) {
49714       {
49715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49716       };
49717     } catch (Dali::DaliException e) {
49718       {
49719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49720       };
49721     } catch (...) {
49722       {
49723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49724       };
49725     }
49726   }
49727
49728 }
49729
49730
49731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
49732   void * jresult ;
49733   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
49734   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49735
49736   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49737   if (!arg1) {
49738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49739     return 0;
49740   }
49741   {
49742     try {
49743       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
49744     } catch (std::out_of_range& e) {
49745       {
49746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49747       };
49748     } catch (std::exception& e) {
49749       {
49750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49751       };
49752     } catch (Dali::DaliException e) {
49753       {
49754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49755       };
49756     } catch (...) {
49757       {
49758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49759       };
49760     }
49761   }
49762
49763   jresult = (void *)result;
49764   return jresult;
49765 }
49766
49767
49768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
49769   void * jresult ;
49770   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49771   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
49772   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49773
49774   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49775   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
49776   if (!arg2) {
49777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49778     return 0;
49779   }
49780   {
49781     try {
49782       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
49783     } catch (std::out_of_range& e) {
49784       {
49785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49786       };
49787     } catch (std::exception& e) {
49788       {
49789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49790       };
49791     } catch (Dali::DaliException e) {
49792       {
49793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49794       };
49795     } catch (...) {
49796       {
49797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49798       };
49799     }
49800   }
49801
49802   jresult = (void *)result;
49803   return jresult;
49804 }
49805
49806
49807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
49808   void * jresult ;
49809   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49810   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49811
49812   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49813   {
49814     try {
49815       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
49816     } catch (std::out_of_range& e) {
49817       {
49818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49819       };
49820     } catch (std::exception& e) {
49821       {
49822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49823       };
49824     } catch (Dali::DaliException e) {
49825       {
49826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49827       };
49828     } catch (...) {
49829       {
49830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49831       };
49832     }
49833   }
49834
49835   jresult = (void *)result;
49836   return jresult;
49837 }
49838
49839
49840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
49841   void * jresult ;
49842   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49843   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49844
49845   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49846   {
49847     try {
49848       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
49849     } catch (std::out_of_range& e) {
49850       {
49851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49852       };
49853     } catch (std::exception& e) {
49854       {
49855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49856       };
49857     } catch (Dali::DaliException e) {
49858       {
49859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49860       };
49861     } catch (...) {
49862       {
49863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49864       };
49865     }
49866   }
49867
49868   jresult = (void *)result;
49869   return jresult;
49870 }
49871
49872
49873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49874   void * jresult ;
49875   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49876   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49877   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
49878
49879   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49880   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49881   {
49882     try {
49883       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
49884     } catch (std::out_of_range& e) {
49885       {
49886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49887       };
49888     } catch (std::exception& e) {
49889       {
49890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49891       };
49892     } catch (Dali::DaliException e) {
49893       {
49894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49895       };
49896     } catch (...) {
49897       {
49898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49899       };
49900     }
49901   }
49902
49903   jresult = (void *)result;
49904   return jresult;
49905 }
49906
49907
49908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
49909   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49910   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
49911
49912   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49913   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
49914   if (!arg2) {
49915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49916     return ;
49917   }
49918   {
49919     try {
49920       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
49921     } catch (std::out_of_range& e) {
49922       {
49923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49924       };
49925     } catch (std::exception& e) {
49926       {
49927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49928       };
49929     } catch (Dali::DaliException e) {
49930       {
49931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49932       };
49933     } catch (...) {
49934       {
49935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49936       };
49937     }
49938   }
49939
49940 }
49941
49942
49943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
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 >::ItemType *arg3 = 0 ;
49947
49948   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49949   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49950   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
49951   if (!arg3) {
49952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49953     return ;
49954   }
49955   {
49956     try {
49957       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
49958     } catch (std::out_of_range& e) {
49959       {
49960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49961       };
49962     } catch (std::exception& e) {
49963       {
49964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49965       };
49966     } catch (Dali::DaliException e) {
49967       {
49968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49969       };
49970     } catch (...) {
49971       {
49972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49973       };
49974     }
49975   }
49976
49977 }
49978
49979
49980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
49981   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49982   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49983   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49984   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49985
49986   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49987   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49988   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
49989   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
49990   {
49991     try {
49992       (arg1)->Insert(arg2,arg3,arg4);
49993     } catch (std::out_of_range& e) {
49994       {
49995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49996       };
49997     } catch (std::exception& e) {
49998       {
49999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50000       };
50001     } catch (Dali::DaliException e) {
50002       {
50003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50004       };
50005     } catch (...) {
50006       {
50007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50008       };
50009     }
50010   }
50011
50012 }
50013
50014
50015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
50016   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50017   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50018
50019   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50020   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50021   {
50022     try {
50023       (arg1)->Reserve(arg2);
50024     } catch (std::out_of_range& e) {
50025       {
50026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50027       };
50028     } catch (std::exception& e) {
50029       {
50030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50031       };
50032     } catch (Dali::DaliException e) {
50033       {
50034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50035       };
50036     } catch (...) {
50037       {
50038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50039       };
50040     }
50041   }
50042
50043 }
50044
50045
50046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
50047   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50048   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50049
50050   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50051   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50052   {
50053     try {
50054       (arg1)->Resize(arg2);
50055     } catch (std::out_of_range& e) {
50056       {
50057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50058       };
50059     } catch (std::exception& e) {
50060       {
50061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50062       };
50063     } catch (Dali::DaliException e) {
50064       {
50065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50066       };
50067     } catch (...) {
50068       {
50069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50070       };
50071     }
50072   }
50073
50074 }
50075
50076
50077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
50078   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50079   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50080   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
50081
50082   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50083   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50084   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
50085   if (!arg3) {
50086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50087     return ;
50088   }
50089   {
50090     try {
50091       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
50092     } catch (std::out_of_range& e) {
50093       {
50094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50095       };
50096     } catch (std::exception& e) {
50097       {
50098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50099       };
50100     } catch (Dali::DaliException e) {
50101       {
50102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50103       };
50104     } catch (...) {
50105       {
50106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50107       };
50108     }
50109   }
50110
50111 }
50112
50113
50114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
50115   void * jresult ;
50116   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50117   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50118   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50119
50120   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50121   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50122   {
50123     try {
50124       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
50125     } catch (std::out_of_range& e) {
50126       {
50127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50128       };
50129     } catch (std::exception& e) {
50130       {
50131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50132       };
50133     } catch (Dali::DaliException e) {
50134       {
50135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50136       };
50137     } catch (...) {
50138       {
50139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50140       };
50141     }
50142   }
50143
50144   jresult = (void *)result;
50145   return jresult;
50146 }
50147
50148
50149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
50150   void * jresult ;
50151   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50152   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50153   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50154   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50155
50156   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50157   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50158   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50159   {
50160     try {
50161       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
50162     } catch (std::out_of_range& e) {
50163       {
50164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50165       };
50166     } catch (std::exception& e) {
50167       {
50168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50169       };
50170     } catch (Dali::DaliException e) {
50171       {
50172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50173       };
50174     } catch (...) {
50175       {
50176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50177       };
50178     }
50179   }
50180
50181   jresult = (void *)result;
50182   return jresult;
50183 }
50184
50185
50186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
50187   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50188   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50189
50190   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50191   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50192   {
50193     try {
50194       (arg1)->Remove(arg2);
50195     } catch (std::out_of_range& e) {
50196       {
50197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50198       };
50199     } catch (std::exception& e) {
50200       {
50201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50202       };
50203     } catch (Dali::DaliException e) {
50204       {
50205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50206       };
50207     } catch (...) {
50208       {
50209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50210       };
50211     }
50212   }
50213
50214 }
50215
50216
50217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
50218   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50219   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
50220
50221   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50222   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
50223   if (!arg2) {
50224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
50225     return ;
50226   }
50227   {
50228     try {
50229       (arg1)->Swap(*arg2);
50230     } catch (std::out_of_range& e) {
50231       {
50232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50233       };
50234     } catch (std::exception& e) {
50235       {
50236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50237       };
50238     } catch (Dali::DaliException e) {
50239       {
50240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50241       };
50242     } catch (...) {
50243       {
50244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50245       };
50246     }
50247   }
50248
50249 }
50250
50251
50252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
50253   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50254
50255   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50256   {
50257     try {
50258       (arg1)->Clear();
50259     } catch (std::out_of_range& e) {
50260       {
50261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50262       };
50263     } catch (std::exception& e) {
50264       {
50265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50266       };
50267     } catch (Dali::DaliException e) {
50268       {
50269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50270       };
50271     } catch (...) {
50272       {
50273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50274       };
50275     }
50276   }
50277
50278 }
50279
50280
50281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
50282   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50283
50284   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50285   {
50286     try {
50287       (arg1)->Release();
50288     } catch (std::out_of_range& e) {
50289       {
50290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50291       };
50292     } catch (std::exception& e) {
50293       {
50294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50295       };
50296     } catch (Dali::DaliException e) {
50297       {
50298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50299       };
50300     } catch (...) {
50301       {
50302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50303       };
50304     }
50305   }
50306
50307 }
50308
50309
50310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
50311   void * jresult ;
50312   Dali::Signal< void () > *result = 0 ;
50313
50314   {
50315     try {
50316       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
50317     } catch (std::out_of_range& e) {
50318       {
50319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50320       };
50321     } catch (std::exception& e) {
50322       {
50323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50324       };
50325     } catch (Dali::DaliException e) {
50326       {
50327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50328       };
50329     } catch (...) {
50330       {
50331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50332       };
50333     }
50334   }
50335
50336   jresult = (void *)result;
50337   return jresult;
50338 }
50339
50340
50341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
50342   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50343
50344   arg1 = (Dali::Signal< void () > *)jarg1;
50345   {
50346     try {
50347       delete arg1;
50348     } catch (std::out_of_range& e) {
50349       {
50350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50351       };
50352     } catch (std::exception& e) {
50353       {
50354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50355       };
50356     } catch (Dali::DaliException e) {
50357       {
50358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50359       };
50360     } catch (...) {
50361       {
50362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50363       };
50364     }
50365   }
50366
50367 }
50368
50369
50370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
50371   unsigned int jresult ;
50372   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50373   bool result;
50374
50375   arg1 = (Dali::Signal< void () > *)jarg1;
50376   {
50377     try {
50378       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
50379     } catch (std::out_of_range& e) {
50380       {
50381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50382       };
50383     } catch (std::exception& e) {
50384       {
50385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50386       };
50387     } catch (Dali::DaliException e) {
50388       {
50389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50390       };
50391     } catch (...) {
50392       {
50393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50394       };
50395     }
50396   }
50397
50398   jresult = result;
50399   return jresult;
50400 }
50401
50402
50403 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
50404   unsigned long jresult ;
50405   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50406   std::size_t result;
50407
50408   arg1 = (Dali::Signal< void () > *)jarg1;
50409   {
50410     try {
50411       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
50412     } catch (std::out_of_range& e) {
50413       {
50414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50415       };
50416     } catch (std::exception& e) {
50417       {
50418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50419       };
50420     } catch (Dali::DaliException e) {
50421       {
50422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50423       };
50424     } catch (...) {
50425       {
50426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50427       };
50428     }
50429   }
50430
50431   jresult = (unsigned long)result;
50432   return jresult;
50433 }
50434
50435
50436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
50437   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50438   void (*arg2)() = (void (*)()) 0 ;
50439
50440   arg1 = (Dali::Signal< void () > *)jarg1;
50441   arg2 = (void (*)())jarg2;
50442   {
50443     try {
50444       (arg1)->Connect(arg2);
50445     } catch (std::out_of_range& e) {
50446       {
50447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50448       };
50449     } catch (std::exception& e) {
50450       {
50451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50452       };
50453     } catch (Dali::DaliException e) {
50454       {
50455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50456       };
50457     } catch (...) {
50458       {
50459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50460       };
50461     }
50462   }
50463
50464 }
50465
50466
50467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
50468   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50469   void (*arg2)() = (void (*)()) 0 ;
50470
50471   arg1 = (Dali::Signal< void () > *)jarg1;
50472   arg2 = (void (*)())jarg2;
50473   {
50474     try {
50475       (arg1)->Disconnect(arg2);
50476     } catch (std::out_of_range& e) {
50477       {
50478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50479       };
50480     } catch (std::exception& e) {
50481       {
50482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50483       };
50484     } catch (Dali::DaliException e) {
50485       {
50486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50487       };
50488     } catch (...) {
50489       {
50490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50491       };
50492     }
50493   }
50494
50495 }
50496
50497
50498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
50499   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50500   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
50501   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
50502
50503   arg1 = (Dali::Signal< void () > *)jarg1;
50504   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
50505   arg3 = (Dali::FunctorDelegate *)jarg3;
50506   {
50507     try {
50508       (arg1)->Connect(arg2,arg3);
50509     } catch (std::out_of_range& e) {
50510       {
50511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50512       };
50513     } catch (std::exception& e) {
50514       {
50515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50516       };
50517     } catch (Dali::DaliException e) {
50518       {
50519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50520       };
50521     } catch (...) {
50522       {
50523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50524       };
50525     }
50526   }
50527
50528 }
50529
50530
50531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
50532   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50533
50534   arg1 = (Dali::Signal< void () > *)jarg1;
50535   {
50536     try {
50537       (arg1)->Emit();
50538     } catch (std::out_of_range& e) {
50539       {
50540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50541       };
50542     } catch (std::exception& e) {
50543       {
50544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50545       };
50546     } catch (Dali::DaliException e) {
50547       {
50548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50549       };
50550     } catch (...) {
50551       {
50552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50553       };
50554     }
50555   }
50556
50557 }
50558
50559
50560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
50561   unsigned int jresult ;
50562   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50563   bool result;
50564
50565   arg1 = (Dali::Signal< void (float) > *)jarg1;
50566   {
50567     try {
50568       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
50569     } catch (std::out_of_range& e) {
50570       {
50571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50572       };
50573     } catch (std::exception& e) {
50574       {
50575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50576       };
50577     } catch (Dali::DaliException e) {
50578       {
50579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50580       };
50581     } catch (...) {
50582       {
50583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50584       };
50585     }
50586   }
50587
50588   jresult = result;
50589   return jresult;
50590 }
50591
50592
50593 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
50594   unsigned long jresult ;
50595   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50596   std::size_t result;
50597
50598   arg1 = (Dali::Signal< void (float) > *)jarg1;
50599   {
50600     try {
50601       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
50602     } catch (std::out_of_range& e) {
50603       {
50604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50605       };
50606     } catch (std::exception& e) {
50607       {
50608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50609       };
50610     } catch (Dali::DaliException e) {
50611       {
50612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50613       };
50614     } catch (...) {
50615       {
50616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50617       };
50618     }
50619   }
50620
50621   jresult = (unsigned long)result;
50622   return jresult;
50623 }
50624
50625
50626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
50627   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50628   void (*arg2)(float) = (void (*)(float)) 0 ;
50629
50630   arg1 = (Dali::Signal< void (float) > *)jarg1;
50631   arg2 = (void (*)(float))jarg2;
50632   {
50633     try {
50634       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
50635     } catch (std::out_of_range& e) {
50636       {
50637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50638       };
50639     } catch (std::exception& e) {
50640       {
50641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50642       };
50643     } catch (Dali::DaliException e) {
50644       {
50645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50646       };
50647     } catch (...) {
50648       {
50649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50650       };
50651     }
50652   }
50653
50654 }
50655
50656
50657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
50658   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50659   void (*arg2)(float) = (void (*)(float)) 0 ;
50660
50661   arg1 = (Dali::Signal< void (float) > *)jarg1;
50662   arg2 = (void (*)(float))jarg2;
50663   {
50664     try {
50665       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
50666     } catch (std::out_of_range& e) {
50667       {
50668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50669       };
50670     } catch (std::exception& e) {
50671       {
50672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50673       };
50674     } catch (Dali::DaliException e) {
50675       {
50676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50677       };
50678     } catch (...) {
50679       {
50680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50681       };
50682     }
50683   }
50684
50685 }
50686
50687
50688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
50689   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50690   float arg2 ;
50691
50692   arg1 = (Dali::Signal< void (float) > *)jarg1;
50693   arg2 = (float)jarg2;
50694   {
50695     try {
50696       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
50697     } catch (std::out_of_range& e) {
50698       {
50699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50700       };
50701     } catch (std::exception& e) {
50702       {
50703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50704       };
50705     } catch (Dali::DaliException e) {
50706       {
50707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50708       };
50709     } catch (...) {
50710       {
50711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50712       };
50713     }
50714   }
50715
50716 }
50717
50718
50719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
50720   void * jresult ;
50721   Dali::Signal< void (float) > *result = 0 ;
50722
50723   {
50724     try {
50725       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
50726     } catch (std::out_of_range& e) {
50727       {
50728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50729       };
50730     } catch (std::exception& e) {
50731       {
50732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50733       };
50734     } catch (Dali::DaliException e) {
50735       {
50736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50737       };
50738     } catch (...) {
50739       {
50740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50741       };
50742     }
50743   }
50744
50745   jresult = (void *)result;
50746   return jresult;
50747 }
50748
50749
50750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
50751   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50752
50753   arg1 = (Dali::Signal< void (float) > *)jarg1;
50754   {
50755     try {
50756       delete arg1;
50757     } catch (std::out_of_range& e) {
50758       {
50759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50760       };
50761     } catch (std::exception& e) {
50762       {
50763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50764       };
50765     } catch (Dali::DaliException e) {
50766       {
50767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50768       };
50769     } catch (...) {
50770       {
50771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50772       };
50773     }
50774   }
50775
50776 }
50777
50778
50779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
50780   unsigned int jresult ;
50781   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50782   bool result;
50783
50784   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50785   {
50786     try {
50787       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50788     } catch (std::out_of_range& e) {
50789       {
50790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50791       };
50792     } catch (std::exception& e) {
50793       {
50794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50795       };
50796     } catch (Dali::DaliException e) {
50797       {
50798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50799       };
50800     } catch (...) {
50801       {
50802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50803       };
50804     }
50805   }
50806
50807   jresult = result;
50808   return jresult;
50809 }
50810
50811
50812 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
50813   unsigned long jresult ;
50814   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50815   std::size_t result;
50816
50817   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50818   {
50819     try {
50820       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50821     } catch (std::out_of_range& e) {
50822       {
50823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50824       };
50825     } catch (std::exception& e) {
50826       {
50827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50828       };
50829     } catch (Dali::DaliException e) {
50830       {
50831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50832       };
50833     } catch (...) {
50834       {
50835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50836       };
50837     }
50838   }
50839
50840   jresult = (unsigned long)result;
50841   return jresult;
50842 }
50843
50844
50845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
50846   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50847   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50848
50849   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50850   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50851   {
50852     try {
50853       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
50854     } catch (std::out_of_range& e) {
50855       {
50856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50857       };
50858     } catch (std::exception& e) {
50859       {
50860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50861       };
50862     } catch (Dali::DaliException e) {
50863       {
50864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50865       };
50866     } catch (...) {
50867       {
50868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50869       };
50870     }
50871   }
50872
50873 }
50874
50875
50876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
50877   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50878   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50879
50880   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50881   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50882   {
50883     try {
50884       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
50885     } catch (std::out_of_range& e) {
50886       {
50887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50888       };
50889     } catch (std::exception& e) {
50890       {
50891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50892       };
50893     } catch (Dali::DaliException e) {
50894       {
50895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50896       };
50897     } catch (...) {
50898       {
50899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50900       };
50901     }
50902   }
50903
50904 }
50905
50906
50907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
50908   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50909   Dali::BaseHandle arg2 ;
50910   Dali::BaseHandle *argp2 ;
50911
50912   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50913   argp2 = (Dali::BaseHandle *)jarg2;
50914   if (!argp2) {
50915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50916     return ;
50917   }
50918   arg2 = *argp2;
50919   {
50920     try {
50921       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
50922     } catch (std::out_of_range& e) {
50923       {
50924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50925       };
50926     } catch (std::exception& e) {
50927       {
50928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50929       };
50930     } catch (Dali::DaliException e) {
50931       {
50932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50933       };
50934     } catch (...) {
50935       {
50936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50937       };
50938     }
50939   }
50940
50941 }
50942
50943
50944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
50945   void * jresult ;
50946   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
50947
50948   {
50949     try {
50950       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
50951     } catch (std::out_of_range& e) {
50952       {
50953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50954       };
50955     } catch (std::exception& e) {
50956       {
50957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50958       };
50959     } catch (Dali::DaliException e) {
50960       {
50961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50962       };
50963     } catch (...) {
50964       {
50965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50966       };
50967     }
50968   }
50969
50970   jresult = (void *)result;
50971   return jresult;
50972 }
50973
50974
50975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
50976   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50977
50978   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50979   {
50980     try {
50981       delete arg1;
50982     } catch (std::out_of_range& e) {
50983       {
50984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50985       };
50986     } catch (std::exception& e) {
50987       {
50988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50989       };
50990     } catch (Dali::DaliException e) {
50991       {
50992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50993       };
50994     } catch (...) {
50995       {
50996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50997       };
50998     }
50999   }
51000
51001 }
51002
51003
51004 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
51005   unsigned int jresult ;
51006   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51007   bool result;
51008
51009   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51010   {
51011     try {
51012       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51013     } catch (std::out_of_range& e) {
51014       {
51015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51016       };
51017     } catch (std::exception& e) {
51018       {
51019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51020       };
51021     } catch (Dali::DaliException e) {
51022       {
51023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51024       };
51025     } catch (...) {
51026       {
51027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51028       };
51029     }
51030   }
51031
51032   jresult = result;
51033   return jresult;
51034 }
51035
51036
51037 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
51038   unsigned long jresult ;
51039   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51040   std::size_t result;
51041
51042   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51043   {
51044     try {
51045       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51046     } catch (std::out_of_range& e) {
51047       {
51048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51049       };
51050     } catch (std::exception& e) {
51051       {
51052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51053       };
51054     } catch (Dali::DaliException e) {
51055       {
51056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51057       };
51058     } catch (...) {
51059       {
51060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51061       };
51062     }
51063   }
51064
51065   jresult = (unsigned long)result;
51066   return jresult;
51067 }
51068
51069
51070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
51071   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51072   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51073
51074   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51075   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51076   {
51077     try {
51078       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
51079     } catch (std::out_of_range& e) {
51080       {
51081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51082       };
51083     } catch (std::exception& e) {
51084       {
51085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51086       };
51087     } catch (Dali::DaliException e) {
51088       {
51089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51090       };
51091     } catch (...) {
51092       {
51093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51094       };
51095     }
51096   }
51097
51098 }
51099
51100
51101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
51102   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51103   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51104
51105   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51106   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51107   {
51108     try {
51109       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
51110     } catch (std::out_of_range& e) {
51111       {
51112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51113       };
51114     } catch (std::exception& e) {
51115       {
51116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51117       };
51118     } catch (Dali::DaliException e) {
51119       {
51120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51121       };
51122     } catch (...) {
51123       {
51124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51125       };
51126     }
51127   }
51128
51129 }
51130
51131
51132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
51133   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51134   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
51135
51136   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51137   arg2 = (Dali::RefObject *)jarg2;
51138   {
51139     try {
51140       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
51141     } catch (std::out_of_range& e) {
51142       {
51143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51144       };
51145     } catch (std::exception& e) {
51146       {
51147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51148       };
51149     } catch (Dali::DaliException e) {
51150       {
51151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51152       };
51153     } catch (...) {
51154       {
51155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51156       };
51157     }
51158   }
51159
51160 }
51161
51162
51163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
51164   void * jresult ;
51165   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
51166
51167   {
51168     try {
51169       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
51170     } catch (std::out_of_range& e) {
51171       {
51172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51173       };
51174     } catch (std::exception& e) {
51175       {
51176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51177       };
51178     } catch (Dali::DaliException e) {
51179       {
51180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51181       };
51182     } catch (...) {
51183       {
51184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51185       };
51186     }
51187   }
51188
51189   jresult = (void *)result;
51190   return jresult;
51191 }
51192
51193
51194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
51195   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51196
51197   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51198   {
51199     try {
51200       delete arg1;
51201     } catch (std::out_of_range& e) {
51202       {
51203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51204       };
51205     } catch (std::exception& e) {
51206       {
51207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51208       };
51209     } catch (Dali::DaliException e) {
51210       {
51211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51212       };
51213     } catch (...) {
51214       {
51215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51216       };
51217     }
51218   }
51219
51220 }
51221
51222
51223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
51224   unsigned int jresult ;
51225   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51226   bool result;
51227
51228   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51229   {
51230     try {
51231       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51232     } catch (std::out_of_range& e) {
51233       {
51234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51235       };
51236     } catch (std::exception& e) {
51237       {
51238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51239       };
51240     } catch (Dali::DaliException e) {
51241       {
51242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51243       };
51244     } catch (...) {
51245       {
51246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51247       };
51248     }
51249   }
51250
51251   jresult = result;
51252   return jresult;
51253 }
51254
51255
51256 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
51257   unsigned long jresult ;
51258   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51259   std::size_t result;
51260
51261   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51262   {
51263     try {
51264       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51265     } catch (std::out_of_range& e) {
51266       {
51267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51268       };
51269     } catch (std::exception& e) {
51270       {
51271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51272       };
51273     } catch (Dali::DaliException e) {
51274       {
51275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51276       };
51277     } catch (...) {
51278       {
51279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51280       };
51281     }
51282   }
51283
51284   jresult = (unsigned long)result;
51285   return jresult;
51286 }
51287
51288
51289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
51290   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51291   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51292
51293   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51294   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51295   {
51296     try {
51297       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
51298     } catch (std::out_of_range& e) {
51299       {
51300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51301       };
51302     } catch (std::exception& e) {
51303       {
51304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51305       };
51306     } catch (Dali::DaliException e) {
51307       {
51308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51309       };
51310     } catch (...) {
51311       {
51312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51313       };
51314     }
51315   }
51316
51317 }
51318
51319
51320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
51321   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51322   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51323
51324   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51325   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51326   {
51327     try {
51328       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
51329     } catch (std::out_of_range& e) {
51330       {
51331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51332       };
51333     } catch (std::exception& e) {
51334       {
51335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51336       };
51337     } catch (Dali::DaliException e) {
51338       {
51339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51340       };
51341     } catch (...) {
51342       {
51343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51344       };
51345     }
51346   }
51347
51348 }
51349
51350
51351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
51352   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51353   Dali::PropertyNotification *arg2 = 0 ;
51354
51355   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51356   arg2 = (Dali::PropertyNotification *)jarg2;
51357   if (!arg2) {
51358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
51359     return ;
51360   }
51361   {
51362     try {
51363       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
51364     } catch (std::out_of_range& e) {
51365       {
51366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51367       };
51368     } catch (std::exception& e) {
51369       {
51370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51371       };
51372     } catch (Dali::DaliException e) {
51373       {
51374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51375       };
51376     } catch (...) {
51377       {
51378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51379       };
51380     }
51381   }
51382
51383 }
51384
51385
51386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
51387   void * jresult ;
51388   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
51389
51390   {
51391     try {
51392       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
51393     } catch (std::out_of_range& e) {
51394       {
51395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51396       };
51397     } catch (std::exception& e) {
51398       {
51399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51400       };
51401     } catch (Dali::DaliException e) {
51402       {
51403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51404       };
51405     } catch (...) {
51406       {
51407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51408       };
51409     }
51410   }
51411
51412   jresult = (void *)result;
51413   return jresult;
51414 }
51415
51416
51417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
51418   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51419
51420   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51421   {
51422     try {
51423       delete arg1;
51424     } catch (std::out_of_range& e) {
51425       {
51426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51427       };
51428     } catch (std::exception& e) {
51429       {
51430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51431       };
51432     } catch (Dali::DaliException e) {
51433       {
51434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51435       };
51436     } catch (...) {
51437       {
51438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51439       };
51440     }
51441   }
51442
51443 }
51444
51445
51446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
51447   void * jresult ;
51448   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
51449
51450   {
51451     try {
51452       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
51453     } catch (std::out_of_range& e) {
51454       {
51455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51456       };
51457     } catch (std::exception& e) {
51458       {
51459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51460       };
51461     } catch (Dali::DaliException e) {
51462       {
51463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51464       };
51465     } catch (...) {
51466       {
51467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51468       };
51469     }
51470   }
51471
51472   jresult = (void *)result;
51473   return jresult;
51474 }
51475
51476
51477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
51478   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
51479
51480   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
51481   {
51482     try {
51483       delete arg1;
51484     } catch (std::out_of_range& e) {
51485       {
51486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51487       };
51488     } catch (std::exception& e) {
51489       {
51490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51491       };
51492     } catch (Dali::DaliException e) {
51493       {
51494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51495       };
51496     } catch (...) {
51497       {
51498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51499       };
51500     }
51501   }
51502
51503 }
51504
51505
51506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
51507   unsigned int jresult ;
51508   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51509   bool result;
51510
51511   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51512   {
51513     try {
51514       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);
51515     } catch (std::out_of_range& e) {
51516       {
51517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51518       };
51519     } catch (std::exception& e) {
51520       {
51521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51522       };
51523     } catch (Dali::DaliException e) {
51524       {
51525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51526       };
51527     } catch (...) {
51528       {
51529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51530       };
51531     }
51532   }
51533
51534   jresult = result;
51535   return jresult;
51536 }
51537
51538
51539 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51540   unsigned long jresult ;
51541   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51542   std::size_t result;
51543
51544   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51545   {
51546     try {
51547       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);
51548     } catch (std::out_of_range& e) {
51549       {
51550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51551       };
51552     } catch (std::exception& e) {
51553       {
51554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51555       };
51556     } catch (Dali::DaliException e) {
51557       {
51558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51559       };
51560     } catch (...) {
51561       {
51562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51563       };
51564     }
51565   }
51566
51567   jresult = (unsigned long)result;
51568   return jresult;
51569 }
51570
51571
51572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51573   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51574   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51575
51576   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51577   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51578   {
51579     try {
51580       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51581     } catch (std::out_of_range& e) {
51582       {
51583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51584       };
51585     } catch (std::exception& e) {
51586       {
51587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51588       };
51589     } catch (Dali::DaliException e) {
51590       {
51591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51592       };
51593     } catch (...) {
51594       {
51595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51596       };
51597     }
51598   }
51599
51600 }
51601
51602
51603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51604   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51605   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51606
51607   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51608   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51609   {
51610     try {
51611       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51612     } catch (std::out_of_range& e) {
51613       {
51614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51615       };
51616     } catch (std::exception& e) {
51617       {
51618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51619       };
51620     } catch (Dali::DaliException e) {
51621       {
51622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51623       };
51624     } catch (...) {
51625       {
51626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51627       };
51628     }
51629   }
51630
51631 }
51632
51633
51634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51635   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51636   Dali::Actor arg2 ;
51637   Dali::LongPressGesture *arg3 = 0 ;
51638   Dali::Actor *argp2 ;
51639
51640   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51641   argp2 = (Dali::Actor *)jarg2;
51642   if (!argp2) {
51643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51644     return ;
51645   }
51646   arg2 = *argp2;
51647   arg3 = (Dali::LongPressGesture *)jarg3;
51648   if (!arg3) {
51649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
51650     return ;
51651   }
51652   {
51653     try {
51654       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
51655     } catch (std::out_of_range& e) {
51656       {
51657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51658       };
51659     } catch (std::exception& e) {
51660       {
51661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51662       };
51663     } catch (Dali::DaliException e) {
51664       {
51665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51666       };
51667     } catch (...) {
51668       {
51669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51670       };
51671     }
51672   }
51673
51674 }
51675
51676
51677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
51678   void * jresult ;
51679   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
51680
51681   {
51682     try {
51683       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
51684     } catch (std::out_of_range& e) {
51685       {
51686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51687       };
51688     } catch (std::exception& e) {
51689       {
51690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51691       };
51692     } catch (Dali::DaliException e) {
51693       {
51694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51695       };
51696     } catch (...) {
51697       {
51698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51699       };
51700     }
51701   }
51702
51703   jresult = (void *)result;
51704   return jresult;
51705 }
51706
51707
51708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
51709   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51710
51711   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51712   {
51713     try {
51714       delete arg1;
51715     } catch (std::out_of_range& e) {
51716       {
51717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51718       };
51719     } catch (std::exception& e) {
51720       {
51721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51722       };
51723     } catch (Dali::DaliException e) {
51724       {
51725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51726       };
51727     } catch (...) {
51728       {
51729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51730       };
51731     }
51732   }
51733
51734 }
51735
51736
51737 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
51738   unsigned int jresult ;
51739   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51740   bool result;
51741
51742   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51743   {
51744     try {
51745       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);
51746     } catch (std::out_of_range& e) {
51747       {
51748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51749       };
51750     } catch (std::exception& e) {
51751       {
51752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51753       };
51754     } catch (Dali::DaliException e) {
51755       {
51756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51757       };
51758     } catch (...) {
51759       {
51760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51761       };
51762     }
51763   }
51764
51765   jresult = result;
51766   return jresult;
51767 }
51768
51769
51770 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
51771   unsigned long jresult ;
51772   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51773   std::size_t result;
51774
51775   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51776   {
51777     try {
51778       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);
51779     } catch (std::out_of_range& e) {
51780       {
51781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51782       };
51783     } catch (std::exception& e) {
51784       {
51785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51786       };
51787     } catch (Dali::DaliException e) {
51788       {
51789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51790       };
51791     } catch (...) {
51792       {
51793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51794       };
51795     }
51796   }
51797
51798   jresult = (unsigned long)result;
51799   return jresult;
51800 }
51801
51802
51803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
51804   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51805   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
51806
51807   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51808   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
51809   {
51810     try {
51811       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51812     } catch (std::out_of_range& e) {
51813       {
51814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51815       };
51816     } catch (std::exception& e) {
51817       {
51818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51819       };
51820     } catch (Dali::DaliException e) {
51821       {
51822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51823       };
51824     } catch (...) {
51825       {
51826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51827       };
51828     }
51829   }
51830
51831 }
51832
51833
51834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
51835   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51836   bool (*arg2)(Dali::Actor,Dali::TouchEvent const &) = (bool (*)(Dali::Actor,Dali::TouchEvent const &)) 0 ;
51837
51838   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51839   arg2 = (bool (*)(Dali::Actor,Dali::TouchEvent const &))jarg2;
51840   {
51841     try {
51842       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51843     } catch (std::out_of_range& e) {
51844       {
51845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51846       };
51847     } catch (std::exception& e) {
51848       {
51849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51850       };
51851     } catch (Dali::DaliException e) {
51852       {
51853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51854       };
51855     } catch (...) {
51856       {
51857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51858       };
51859     }
51860   }
51861
51862 }
51863
51864
51865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51866   unsigned int jresult ;
51867   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51868   Dali::Actor arg2 ;
51869   Dali::TouchEvent *arg3 = 0 ;
51870   Dali::Actor *argp2 ;
51871   bool result;
51872
51873   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51874   argp2 = (Dali::Actor *)jarg2;
51875   if (!argp2) {
51876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51877     return 0;
51878   }
51879   arg2 = *argp2;
51880   arg3 = (Dali::TouchEvent *)jarg3;
51881   if (!arg3) {
51882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
51883     return 0;
51884   }
51885   {
51886     try {
51887       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchEvent const &)*arg3);
51888     } catch (std::out_of_range& e) {
51889       {
51890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51891       };
51892     } catch (std::exception& e) {
51893       {
51894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51895       };
51896     } catch (Dali::DaliException e) {
51897       {
51898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51899       };
51900     } catch (...) {
51901       {
51902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51903       };
51904     }
51905   }
51906
51907   jresult = result;
51908   return jresult;
51909 }
51910
51911
51912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
51913   void * jresult ;
51914   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *result = 0 ;
51915
51916   {
51917     try {
51918       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) >();
51919     } catch (std::out_of_range& e) {
51920       {
51921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51922       };
51923     } catch (std::exception& e) {
51924       {
51925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51926       };
51927     } catch (Dali::DaliException e) {
51928       {
51929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51930       };
51931     } catch (...) {
51932       {
51933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51934       };
51935     }
51936   }
51937
51938   jresult = (void *)result;
51939   return jresult;
51940 }
51941
51942
51943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
51944   Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *) 0 ;
51945
51946   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchEvent const &) > *)jarg1;
51947   {
51948     try {
51949       delete arg1;
51950     } catch (std::out_of_range& e) {
51951       {
51952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51953       };
51954     } catch (std::exception& e) {
51955       {
51956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51957       };
51958     } catch (Dali::DaliException e) {
51959       {
51960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51961       };
51962     } catch (...) {
51963       {
51964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51965       };
51966     }
51967   }
51968
51969 }
51970
51971
51972 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
51973   unsigned int jresult ;
51974   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51975   bool result;
51976
51977   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51978   {
51979     try {
51980       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);
51981     } catch (std::out_of_range& e) {
51982       {
51983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51984       };
51985     } catch (std::exception& e) {
51986       {
51987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51988       };
51989     } catch (Dali::DaliException e) {
51990       {
51991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51992       };
51993     } catch (...) {
51994       {
51995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51996       };
51997     }
51998   }
51999
52000   jresult = result;
52001   return jresult;
52002 }
52003
52004
52005 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
52006   unsigned long jresult ;
52007   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52008   std::size_t result;
52009
52010   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52011   {
52012     try {
52013       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);
52014     } catch (std::out_of_range& e) {
52015       {
52016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52017       };
52018     } catch (std::exception& e) {
52019       {
52020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52021       };
52022     } catch (Dali::DaliException e) {
52023       {
52024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52025       };
52026     } catch (...) {
52027       {
52028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52029       };
52030     }
52031   }
52032
52033   jresult = (unsigned long)result;
52034   return jresult;
52035 }
52036
52037
52038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
52039   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52040   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52041
52042   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52043   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52044   {
52045     try {
52046       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52047     } catch (std::out_of_range& e) {
52048       {
52049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52050       };
52051     } catch (std::exception& e) {
52052       {
52053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52054       };
52055     } catch (Dali::DaliException e) {
52056       {
52057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52058       };
52059     } catch (...) {
52060       {
52061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52062       };
52063     }
52064   }
52065
52066 }
52067
52068
52069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
52070   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52071   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52072
52073   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52074   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52075   {
52076     try {
52077       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52078     } catch (std::out_of_range& e) {
52079       {
52080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52081       };
52082     } catch (std::exception& e) {
52083       {
52084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52085       };
52086     } catch (Dali::DaliException e) {
52087       {
52088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52089       };
52090     } catch (...) {
52091       {
52092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52093       };
52094     }
52095   }
52096
52097 }
52098
52099
52100 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52101   unsigned int jresult ;
52102   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52103   Dali::Actor arg2 ;
52104   Dali::HoverEvent *arg3 = 0 ;
52105   Dali::Actor *argp2 ;
52106   bool result;
52107
52108   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52109   argp2 = (Dali::Actor *)jarg2;
52110   if (!argp2) {
52111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52112     return 0;
52113   }
52114   arg2 = *argp2;
52115   arg3 = (Dali::HoverEvent *)jarg3;
52116   if (!arg3) {
52117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
52118     return 0;
52119   }
52120   {
52121     try {
52122       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
52123     } catch (std::out_of_range& e) {
52124       {
52125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52126       };
52127     } catch (std::exception& e) {
52128       {
52129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52130       };
52131     } catch (Dali::DaliException e) {
52132       {
52133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52134       };
52135     } catch (...) {
52136       {
52137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52138       };
52139     }
52140   }
52141
52142   jresult = result;
52143   return jresult;
52144 }
52145
52146
52147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
52148   void * jresult ;
52149   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
52150
52151   {
52152     try {
52153       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
52154     } catch (std::out_of_range& e) {
52155       {
52156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52157       };
52158     } catch (std::exception& e) {
52159       {
52160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52161       };
52162     } catch (Dali::DaliException e) {
52163       {
52164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52165       };
52166     } catch (...) {
52167       {
52168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52169       };
52170     }
52171   }
52172
52173   jresult = (void *)result;
52174   return jresult;
52175 }
52176
52177
52178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
52179   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52180
52181   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52182   {
52183     try {
52184       delete arg1;
52185     } catch (std::out_of_range& e) {
52186       {
52187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52188       };
52189     } catch (std::exception& e) {
52190       {
52191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52192       };
52193     } catch (Dali::DaliException e) {
52194       {
52195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52196       };
52197     } catch (...) {
52198       {
52199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52200       };
52201     }
52202   }
52203
52204 }
52205
52206
52207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
52208   unsigned int jresult ;
52209   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52210   bool result;
52211
52212   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52213   {
52214     try {
52215       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);
52216     } catch (std::out_of_range& e) {
52217       {
52218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52219       };
52220     } catch (std::exception& e) {
52221       {
52222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52223       };
52224     } catch (Dali::DaliException e) {
52225       {
52226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52227       };
52228     } catch (...) {
52229       {
52230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52231       };
52232     }
52233   }
52234
52235   jresult = result;
52236   return jresult;
52237 }
52238
52239
52240 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
52241   unsigned long jresult ;
52242   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52243   std::size_t result;
52244
52245   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52246   {
52247     try {
52248       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);
52249     } catch (std::out_of_range& e) {
52250       {
52251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52252       };
52253     } catch (std::exception& e) {
52254       {
52255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52256       };
52257     } catch (Dali::DaliException e) {
52258       {
52259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52260       };
52261     } catch (...) {
52262       {
52263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52264       };
52265     }
52266   }
52267
52268   jresult = (unsigned long)result;
52269   return jresult;
52270 }
52271
52272
52273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
52274   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52275   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52276
52277   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52278   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52279   {
52280     try {
52281       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52282     } catch (std::out_of_range& e) {
52283       {
52284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52285       };
52286     } catch (std::exception& e) {
52287       {
52288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52289       };
52290     } catch (Dali::DaliException e) {
52291       {
52292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52293       };
52294     } catch (...) {
52295       {
52296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52297       };
52298     }
52299   }
52300
52301 }
52302
52303
52304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
52305   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52306   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52307
52308   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52309   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52310   {
52311     try {
52312       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52313     } catch (std::out_of_range& e) {
52314       {
52315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52316       };
52317     } catch (std::exception& e) {
52318       {
52319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52320       };
52321     } catch (Dali::DaliException e) {
52322       {
52323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52324       };
52325     } catch (...) {
52326       {
52327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52328       };
52329     }
52330   }
52331
52332 }
52333
52334
52335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52336   unsigned int jresult ;
52337   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52338   Dali::Actor arg2 ;
52339   Dali::WheelEvent *arg3 = 0 ;
52340   Dali::Actor *argp2 ;
52341   bool result;
52342
52343   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52344   argp2 = (Dali::Actor *)jarg2;
52345   if (!argp2) {
52346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52347     return 0;
52348   }
52349   arg2 = *argp2;
52350   arg3 = (Dali::WheelEvent *)jarg3;
52351   if (!arg3) {
52352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
52353     return 0;
52354   }
52355   {
52356     try {
52357       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
52358     } catch (std::out_of_range& e) {
52359       {
52360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52361       };
52362     } catch (std::exception& e) {
52363       {
52364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52365       };
52366     } catch (Dali::DaliException e) {
52367       {
52368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52369       };
52370     } catch (...) {
52371       {
52372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52373       };
52374     }
52375   }
52376
52377   jresult = result;
52378   return jresult;
52379 }
52380
52381
52382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
52383   void * jresult ;
52384   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
52385
52386   {
52387     try {
52388       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
52389     } catch (std::out_of_range& e) {
52390       {
52391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52392       };
52393     } catch (std::exception& e) {
52394       {
52395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52396       };
52397     } catch (Dali::DaliException e) {
52398       {
52399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52400       };
52401     } catch (...) {
52402       {
52403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52404       };
52405     }
52406   }
52407
52408   jresult = (void *)result;
52409   return jresult;
52410 }
52411
52412
52413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
52414   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52415
52416   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52417   {
52418     try {
52419       delete arg1;
52420     } catch (std::out_of_range& e) {
52421       {
52422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52423       };
52424     } catch (std::exception& e) {
52425       {
52426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52427       };
52428     } catch (Dali::DaliException e) {
52429       {
52430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52431       };
52432     } catch (...) {
52433       {
52434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52435       };
52436     }
52437   }
52438
52439 }
52440
52441
52442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
52443   unsigned int jresult ;
52444   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52445   bool result;
52446
52447   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52448   {
52449     try {
52450       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
52451     } catch (std::out_of_range& e) {
52452       {
52453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52454       };
52455     } catch (std::exception& e) {
52456       {
52457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52458       };
52459     } catch (Dali::DaliException e) {
52460       {
52461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52462       };
52463     } catch (...) {
52464       {
52465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52466       };
52467     }
52468   }
52469
52470   jresult = result;
52471   return jresult;
52472 }
52473
52474
52475 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
52476   unsigned long jresult ;
52477   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52478   std::size_t result;
52479
52480   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52481   {
52482     try {
52483       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
52484     } catch (std::out_of_range& e) {
52485       {
52486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52487       };
52488     } catch (std::exception& e) {
52489       {
52490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52491       };
52492     } catch (Dali::DaliException e) {
52493       {
52494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52495       };
52496     } catch (...) {
52497       {
52498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52499       };
52500     }
52501   }
52502
52503   jresult = (unsigned long)result;
52504   return jresult;
52505 }
52506
52507
52508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
52509   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52510   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52511
52512   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52513   arg2 = (void (*)(Dali::Actor))jarg2;
52514   {
52515     try {
52516       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
52517     } catch (std::out_of_range& e) {
52518       {
52519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52520       };
52521     } catch (std::exception& e) {
52522       {
52523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52524       };
52525     } catch (Dali::DaliException e) {
52526       {
52527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52528       };
52529     } catch (...) {
52530       {
52531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52532       };
52533     }
52534   }
52535
52536 }
52537
52538
52539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
52540   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52541   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52542
52543   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52544   arg2 = (void (*)(Dali::Actor))jarg2;
52545   {
52546     try {
52547       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
52548     } catch (std::out_of_range& e) {
52549       {
52550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52551       };
52552     } catch (std::exception& e) {
52553       {
52554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52555       };
52556     } catch (Dali::DaliException e) {
52557       {
52558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52559       };
52560     } catch (...) {
52561       {
52562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52563       };
52564     }
52565   }
52566
52567 }
52568
52569
52570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
52571   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52572   Dali::Actor arg2 ;
52573   Dali::Actor *argp2 ;
52574
52575   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52576   argp2 = (Dali::Actor *)jarg2;
52577   if (!argp2) {
52578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52579     return ;
52580   }
52581   arg2 = *argp2;
52582   {
52583     try {
52584       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
52585     } catch (std::out_of_range& e) {
52586       {
52587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52588       };
52589     } catch (std::exception& e) {
52590       {
52591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52592       };
52593     } catch (Dali::DaliException e) {
52594       {
52595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52596       };
52597     } catch (...) {
52598       {
52599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52600       };
52601     }
52602   }
52603
52604 }
52605
52606
52607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
52608   void * jresult ;
52609   Dali::Signal< void (Dali::Actor) > *result = 0 ;
52610
52611   {
52612     try {
52613       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
52614     } catch (std::out_of_range& e) {
52615       {
52616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52617       };
52618     } catch (std::exception& e) {
52619       {
52620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52621       };
52622     } catch (Dali::DaliException e) {
52623       {
52624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52625       };
52626     } catch (...) {
52627       {
52628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52629       };
52630     }
52631   }
52632
52633   jresult = (void *)result;
52634   return jresult;
52635 }
52636
52637
52638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
52639   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52640
52641   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52642   {
52643     try {
52644       delete arg1;
52645     } catch (std::out_of_range& e) {
52646       {
52647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52648       };
52649     } catch (std::exception& e) {
52650       {
52651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52652       };
52653     } catch (Dali::DaliException e) {
52654       {
52655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52656       };
52657     } catch (...) {
52658       {
52659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52660       };
52661     }
52662   }
52663
52664 }
52665
52666
52667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
52668   unsigned int jresult ;
52669   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52670   bool result;
52671
52672   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52673   {
52674     try {
52675       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52676     } catch (std::out_of_range& e) {
52677       {
52678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52679       };
52680     } catch (std::exception& e) {
52681       {
52682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52683       };
52684     } catch (Dali::DaliException e) {
52685       {
52686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52687       };
52688     } catch (...) {
52689       {
52690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52691       };
52692     }
52693   }
52694
52695   jresult = result;
52696   return jresult;
52697 }
52698
52699
52700 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
52701   unsigned long jresult ;
52702   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52703   std::size_t result;
52704
52705   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52706   {
52707     try {
52708       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52709     } catch (std::out_of_range& e) {
52710       {
52711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52712       };
52713     } catch (std::exception& e) {
52714       {
52715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52716       };
52717     } catch (Dali::DaliException e) {
52718       {
52719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52720       };
52721     } catch (...) {
52722       {
52723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52724       };
52725     }
52726   }
52727
52728   jresult = (unsigned long)result;
52729   return jresult;
52730 }
52731
52732
52733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
52734   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52735   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52736
52737   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52738   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52739   {
52740     try {
52741       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52742     } catch (std::out_of_range& e) {
52743       {
52744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52745       };
52746     } catch (std::exception& e) {
52747       {
52748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52749       };
52750     } catch (Dali::DaliException e) {
52751       {
52752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52753       };
52754     } catch (...) {
52755       {
52756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52757       };
52758     }
52759   }
52760
52761 }
52762
52763
52764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
52765   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52766   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52767
52768   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52769   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52770   {
52771     try {
52772       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52773     } catch (std::out_of_range& e) {
52774       {
52775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52776       };
52777     } catch (std::exception& e) {
52778       {
52779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52780       };
52781     } catch (Dali::DaliException e) {
52782       {
52783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52784       };
52785     } catch (...) {
52786       {
52787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52788       };
52789     }
52790   }
52791
52792 }
52793
52794
52795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
52796   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52797   Dali::KeyEvent *arg2 = 0 ;
52798
52799   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52800   arg2 = (Dali::KeyEvent *)jarg2;
52801   if (!arg2) {
52802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
52803     return ;
52804   }
52805   {
52806     try {
52807       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
52808     } catch (std::out_of_range& e) {
52809       {
52810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52811       };
52812     } catch (std::exception& e) {
52813       {
52814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52815       };
52816     } catch (Dali::DaliException e) {
52817       {
52818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52819       };
52820     } catch (...) {
52821       {
52822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52823       };
52824     }
52825   }
52826
52827 }
52828
52829
52830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
52831   void * jresult ;
52832   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
52833
52834   {
52835     try {
52836       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
52837     } catch (std::out_of_range& e) {
52838       {
52839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52840       };
52841     } catch (std::exception& e) {
52842       {
52843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52844       };
52845     } catch (Dali::DaliException e) {
52846       {
52847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52848       };
52849     } catch (...) {
52850       {
52851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52852       };
52853     }
52854   }
52855
52856   jresult = (void *)result;
52857   return jresult;
52858 }
52859
52860
52861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
52862   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52863
52864   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52865   {
52866     try {
52867       delete arg1;
52868     } catch (std::out_of_range& e) {
52869       {
52870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52871       };
52872     } catch (std::exception& e) {
52873       {
52874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52875       };
52876     } catch (Dali::DaliException e) {
52877       {
52878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52879       };
52880     } catch (...) {
52881       {
52882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52883       };
52884     }
52885   }
52886
52887 }
52888
52889
52890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
52891   unsigned int jresult ;
52892   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
52893   bool result;
52894
52895   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
52896   {
52897     try {
52898       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
52899     } catch (std::out_of_range& e) {
52900       {
52901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52902       };
52903     } catch (std::exception& e) {
52904       {
52905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52906       };
52907     } catch (Dali::DaliException e) {
52908       {
52909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52910       };
52911     } catch (...) {
52912       {
52913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52914       };
52915     }
52916   }
52917
52918   jresult = result;
52919   return jresult;
52920 }
52921
52922
52923 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
52924   unsigned long jresult ;
52925   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
52926   std::size_t result;
52927
52928   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
52929   {
52930     try {
52931       result = Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchEvent const &) > const *)arg1);
52932     } catch (std::out_of_range& e) {
52933       {
52934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52935       };
52936     } catch (std::exception& e) {
52937       {
52938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52939       };
52940     } catch (Dali::DaliException e) {
52941       {
52942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52943       };
52944     } catch (...) {
52945       {
52946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52947       };
52948     }
52949   }
52950
52951   jresult = (unsigned long)result;
52952   return jresult;
52953 }
52954
52955
52956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
52957   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
52958   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
52959
52960   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
52961   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
52962   {
52963     try {
52964       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52965     } catch (std::out_of_range& e) {
52966       {
52967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52968       };
52969     } catch (std::exception& e) {
52970       {
52971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52972       };
52973     } catch (Dali::DaliException e) {
52974       {
52975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52976       };
52977     } catch (...) {
52978       {
52979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52980       };
52981     }
52982   }
52983
52984 }
52985
52986
52987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
52988   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
52989   void (*arg2)(Dali::TouchEvent const &) = (void (*)(Dali::TouchEvent const &)) 0 ;
52990
52991   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
52992   arg2 = (void (*)(Dali::TouchEvent const &))jarg2;
52993   {
52994     try {
52995       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52996     } catch (std::out_of_range& e) {
52997       {
52998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52999       };
53000     } catch (std::exception& e) {
53001       {
53002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53003       };
53004     } catch (Dali::DaliException e) {
53005       {
53006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53007       };
53008     } catch (...) {
53009       {
53010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53011       };
53012     }
53013   }
53014
53015 }
53016
53017
53018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
53019   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53020   Dali::TouchEvent *arg2 = 0 ;
53021
53022   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53023   arg2 = (Dali::TouchEvent *)jarg2;
53024   if (!arg2) {
53025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
53026     return ;
53027   }
53028   {
53029     try {
53030       Dali_Signal_Sl_void_Sp_Dali_TouchEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchEvent const &)*arg2);
53031     } catch (std::out_of_range& e) {
53032       {
53033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53034       };
53035     } catch (std::exception& e) {
53036       {
53037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53038       };
53039     } catch (Dali::DaliException e) {
53040       {
53041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53042       };
53043     } catch (...) {
53044       {
53045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53046       };
53047     }
53048   }
53049
53050 }
53051
53052
53053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
53054   void * jresult ;
53055   Dali::Signal< void (Dali::TouchEvent const &) > *result = 0 ;
53056
53057   {
53058     try {
53059       result = (Dali::Signal< void (Dali::TouchEvent const &) > *)new Dali::Signal< void (Dali::TouchEvent const &) >();
53060     } catch (std::out_of_range& e) {
53061       {
53062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53063       };
53064     } catch (std::exception& e) {
53065       {
53066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53067       };
53068     } catch (Dali::DaliException e) {
53069       {
53070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53071       };
53072     } catch (...) {
53073       {
53074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53075       };
53076     }
53077   }
53078
53079   jresult = (void *)result;
53080   return jresult;
53081 }
53082
53083
53084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
53085   Dali::Signal< void (Dali::TouchEvent const &) > *arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *) 0 ;
53086
53087   arg1 = (Dali::Signal< void (Dali::TouchEvent const &) > *)jarg1;
53088   {
53089     try {
53090       delete arg1;
53091     } catch (std::out_of_range& e) {
53092       {
53093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53094       };
53095     } catch (std::exception& e) {
53096       {
53097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53098       };
53099     } catch (Dali::DaliException e) {
53100       {
53101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53102       };
53103     } catch (...) {
53104       {
53105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53106       };
53107     }
53108   }
53109
53110 }
53111
53112
53113 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
53114   unsigned int jresult ;
53115   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53116   bool result;
53117
53118   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53119   {
53120     try {
53121       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53122     } catch (std::out_of_range& e) {
53123       {
53124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53125       };
53126     } catch (std::exception& e) {
53127       {
53128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53129       };
53130     } catch (Dali::DaliException e) {
53131       {
53132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53133       };
53134     } catch (...) {
53135       {
53136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53137       };
53138     }
53139   }
53140
53141   jresult = result;
53142   return jresult;
53143 }
53144
53145
53146 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
53147   unsigned long jresult ;
53148   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53149   std::size_t result;
53150
53151   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53152   {
53153     try {
53154       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53155     } catch (std::out_of_range& e) {
53156       {
53157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53158       };
53159     } catch (std::exception& e) {
53160       {
53161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53162       };
53163     } catch (Dali::DaliException e) {
53164       {
53165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53166       };
53167     } catch (...) {
53168       {
53169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53170       };
53171     }
53172   }
53173
53174   jresult = (unsigned long)result;
53175   return jresult;
53176 }
53177
53178
53179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
53180   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53181   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53182
53183   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53184   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53185   {
53186     try {
53187       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53188     } catch (std::out_of_range& e) {
53189       {
53190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53191       };
53192     } catch (std::exception& e) {
53193       {
53194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53195       };
53196     } catch (Dali::DaliException e) {
53197       {
53198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53199       };
53200     } catch (...) {
53201       {
53202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53203       };
53204     }
53205   }
53206
53207 }
53208
53209
53210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
53211   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53212   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53213
53214   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53215   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53216   {
53217     try {
53218       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53219     } catch (std::out_of_range& e) {
53220       {
53221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53222       };
53223     } catch (std::exception& e) {
53224       {
53225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53226       };
53227     } catch (Dali::DaliException e) {
53228       {
53229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53230       };
53231     } catch (...) {
53232       {
53233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53234       };
53235     }
53236   }
53237
53238 }
53239
53240
53241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
53242   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53243   Dali::WheelEvent *arg2 = 0 ;
53244
53245   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53246   arg2 = (Dali::WheelEvent *)jarg2;
53247   if (!arg2) {
53248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
53249     return ;
53250   }
53251   {
53252     try {
53253       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
53254     } catch (std::out_of_range& e) {
53255       {
53256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53257       };
53258     } catch (std::exception& e) {
53259       {
53260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53261       };
53262     } catch (Dali::DaliException e) {
53263       {
53264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53265       };
53266     } catch (...) {
53267       {
53268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53269       };
53270     }
53271   }
53272
53273 }
53274
53275
53276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
53277   void * jresult ;
53278   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
53279
53280   {
53281     try {
53282       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
53283     } catch (std::out_of_range& e) {
53284       {
53285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53286       };
53287     } catch (std::exception& e) {
53288       {
53289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53290       };
53291     } catch (Dali::DaliException e) {
53292       {
53293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53294       };
53295     } catch (...) {
53296       {
53297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53298       };
53299     }
53300   }
53301
53302   jresult = (void *)result;
53303   return jresult;
53304 }
53305
53306
53307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
53308   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53309
53310   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53311   {
53312     try {
53313       delete arg1;
53314     } catch (std::out_of_range& e) {
53315       {
53316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53317       };
53318     } catch (std::exception& e) {
53319       {
53320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53321       };
53322     } catch (Dali::DaliException e) {
53323       {
53324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53325       };
53326     } catch (...) {
53327       {
53328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53329       };
53330     }
53331   }
53332
53333 }
53334
53335
53336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
53337   void * jresult ;
53338   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53339
53340   {
53341     try {
53342       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
53343     } catch (std::out_of_range& e) {
53344       {
53345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53346       };
53347     } catch (std::exception& e) {
53348       {
53349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53350       };
53351     } catch (Dali::DaliException e) {
53352       {
53353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53354       };
53355     } catch (...) {
53356       {
53357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53358       };
53359     }
53360   }
53361
53362   jresult = (void *)result;
53363   return jresult;
53364 }
53365
53366
53367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
53368   void * jresult ;
53369   Dali::Radian arg1 ;
53370   Dali::Radian arg2 ;
53371   Dali::Radian *argp1 ;
53372   Dali::Radian *argp2 ;
53373   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53374
53375   argp1 = (Dali::Radian *)jarg1;
53376   if (!argp1) {
53377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53378     return 0;
53379   }
53380   arg1 = *argp1;
53381   argp2 = (Dali::Radian *)jarg2;
53382   if (!argp2) {
53383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53384     return 0;
53385   }
53386   arg2 = *argp2;
53387   {
53388     try {
53389       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
53390     } catch (std::out_of_range& e) {
53391       {
53392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53393       };
53394     } catch (std::exception& e) {
53395       {
53396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53397       };
53398     } catch (Dali::DaliException e) {
53399       {
53400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53401       };
53402     } catch (...) {
53403       {
53404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53405       };
53406     }
53407   }
53408
53409   jresult = (void *)result;
53410   return jresult;
53411 }
53412
53413
53414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
53415   void * jresult ;
53416   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
53417   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53418
53419   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53420   if (!arg1) {
53421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
53422     return 0;
53423   }
53424   {
53425     try {
53426       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
53427     } catch (std::out_of_range& e) {
53428       {
53429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53430       };
53431     } catch (std::exception& e) {
53432       {
53433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53434       };
53435     } catch (Dali::DaliException e) {
53436       {
53437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53438       };
53439     } catch (...) {
53440       {
53441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53442       };
53443     }
53444   }
53445
53446   jresult = (void *)result;
53447   return jresult;
53448 }
53449
53450
53451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
53452   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53453   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53454
53455   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53456   arg2 = (Dali::Radian *)jarg2;
53457   if (arg1) (arg1)->first = *arg2;
53458 }
53459
53460
53461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
53462   void * jresult ;
53463   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53464   Dali::Radian *result = 0 ;
53465
53466   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53467   result = (Dali::Radian *)& ((arg1)->first);
53468   jresult = (void *)result;
53469   return jresult;
53470 }
53471
53472
53473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
53474   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53475   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53476
53477   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53478   arg2 = (Dali::Radian *)jarg2;
53479   if (arg1) (arg1)->second = *arg2;
53480 }
53481
53482
53483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
53484   void * jresult ;
53485   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53486   Dali::Radian *result = 0 ;
53487
53488   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53489   result = (Dali::Radian *)& ((arg1)->second);
53490   jresult = (void *)result;
53491   return jresult;
53492 }
53493
53494
53495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
53496   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53497
53498   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53499   {
53500     try {
53501       delete arg1;
53502     } catch (std::out_of_range& e) {
53503       {
53504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53505       };
53506     } catch (std::exception& e) {
53507       {
53508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53509       };
53510     } catch (Dali::DaliException e) {
53511       {
53512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53513       };
53514     } catch (...) {
53515       {
53516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53517       };
53518     }
53519   }
53520
53521 }
53522
53523
53524 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
53525   unsigned int jresult ;
53526   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53527   bool result;
53528
53529   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53530   {
53531     try {
53532       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);
53533     } catch (std::out_of_range& e) {
53534       {
53535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53536       };
53537     } catch (std::exception& e) {
53538       {
53539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53540       };
53541     } catch (Dali::DaliException e) {
53542       {
53543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53544       };
53545     } catch (...) {
53546       {
53547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53548       };
53549     }
53550   }
53551
53552   jresult = result;
53553   return jresult;
53554 }
53555
53556
53557 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53558   unsigned long jresult ;
53559   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53560   std::size_t result;
53561
53562   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53563   {
53564     try {
53565       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);
53566     } catch (std::out_of_range& e) {
53567       {
53568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53569       };
53570     } catch (std::exception& e) {
53571       {
53572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53573       };
53574     } catch (Dali::DaliException e) {
53575       {
53576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53577       };
53578     } catch (...) {
53579       {
53580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53581       };
53582     }
53583   }
53584
53585   jresult = (unsigned long)result;
53586   return jresult;
53587 }
53588
53589
53590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53591   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53592   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53593
53594   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53595   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53596   {
53597     try {
53598       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53599     } catch (std::out_of_range& e) {
53600       {
53601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53602       };
53603     } catch (std::exception& e) {
53604       {
53605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53606       };
53607     } catch (Dali::DaliException e) {
53608       {
53609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53610       };
53611     } catch (...) {
53612       {
53613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53614       };
53615     }
53616   }
53617
53618 }
53619
53620
53621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53622   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53623   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53624
53625   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53626   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53627   {
53628     try {
53629       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53630     } catch (std::out_of_range& e) {
53631       {
53632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53633       };
53634     } catch (std::exception& e) {
53635       {
53636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53637       };
53638     } catch (Dali::DaliException e) {
53639       {
53640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53641       };
53642     } catch (...) {
53643       {
53644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53645       };
53646     }
53647   }
53648
53649 }
53650
53651
53652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53653   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53654   Dali::Actor arg2 ;
53655   Dali::PanGesture *arg3 = 0 ;
53656   Dali::Actor *argp2 ;
53657
53658   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53659   argp2 = (Dali::Actor *)jarg2;
53660   if (!argp2) {
53661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53662     return ;
53663   }
53664   arg2 = *argp2;
53665   arg3 = (Dali::PanGesture *)jarg3;
53666   if (!arg3) {
53667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
53668     return ;
53669   }
53670   {
53671     try {
53672       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
53673     } catch (std::out_of_range& e) {
53674       {
53675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53676       };
53677     } catch (std::exception& e) {
53678       {
53679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53680       };
53681     } catch (Dali::DaliException e) {
53682       {
53683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53684       };
53685     } catch (...) {
53686       {
53687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53688       };
53689     }
53690   }
53691
53692 }
53693
53694
53695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
53696   void * jresult ;
53697   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
53698
53699   {
53700     try {
53701       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
53702     } catch (std::out_of_range& e) {
53703       {
53704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53705       };
53706     } catch (std::exception& e) {
53707       {
53708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53709       };
53710     } catch (Dali::DaliException e) {
53711       {
53712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53713       };
53714     } catch (...) {
53715       {
53716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53717       };
53718     }
53719   }
53720
53721   jresult = (void *)result;
53722   return jresult;
53723 }
53724
53725
53726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
53727   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53728
53729   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53730   {
53731     try {
53732       delete arg1;
53733     } catch (std::out_of_range& e) {
53734       {
53735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53736       };
53737     } catch (std::exception& e) {
53738       {
53739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53740       };
53741     } catch (Dali::DaliException e) {
53742       {
53743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53744       };
53745     } catch (...) {
53746       {
53747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53748       };
53749     }
53750   }
53751
53752 }
53753
53754
53755 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
53756   unsigned int jresult ;
53757   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53758   bool result;
53759
53760   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53761   {
53762     try {
53763       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);
53764     } catch (std::out_of_range& e) {
53765       {
53766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53767       };
53768     } catch (std::exception& e) {
53769       {
53770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53771       };
53772     } catch (Dali::DaliException e) {
53773       {
53774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53775       };
53776     } catch (...) {
53777       {
53778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53779       };
53780     }
53781   }
53782
53783   jresult = result;
53784   return jresult;
53785 }
53786
53787
53788 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53789   unsigned long jresult ;
53790   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53791   std::size_t result;
53792
53793   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53794   {
53795     try {
53796       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);
53797     } catch (std::out_of_range& e) {
53798       {
53799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53800       };
53801     } catch (std::exception& e) {
53802       {
53803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53804       };
53805     } catch (Dali::DaliException e) {
53806       {
53807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53808       };
53809     } catch (...) {
53810       {
53811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53812       };
53813     }
53814   }
53815
53816   jresult = (unsigned long)result;
53817   return jresult;
53818 }
53819
53820
53821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53822   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53823   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53824
53825   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53826   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53827   {
53828     try {
53829       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53830     } catch (std::out_of_range& e) {
53831       {
53832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53833       };
53834     } catch (std::exception& e) {
53835       {
53836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53837       };
53838     } catch (Dali::DaliException e) {
53839       {
53840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53841       };
53842     } catch (...) {
53843       {
53844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53845       };
53846     }
53847   }
53848
53849 }
53850
53851
53852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53853   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53854   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53855
53856   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53857   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53858   {
53859     try {
53860       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53861     } catch (std::out_of_range& e) {
53862       {
53863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53864       };
53865     } catch (std::exception& e) {
53866       {
53867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53868       };
53869     } catch (Dali::DaliException e) {
53870       {
53871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53872       };
53873     } catch (...) {
53874       {
53875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53876       };
53877     }
53878   }
53879
53880 }
53881
53882
53883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53884   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53885   Dali::Actor arg2 ;
53886   Dali::PinchGesture *arg3 = 0 ;
53887   Dali::Actor *argp2 ;
53888
53889   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53890   argp2 = (Dali::Actor *)jarg2;
53891   if (!argp2) {
53892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53893     return ;
53894   }
53895   arg2 = *argp2;
53896   arg3 = (Dali::PinchGesture *)jarg3;
53897   if (!arg3) {
53898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
53899     return ;
53900   }
53901   {
53902     try {
53903       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
53904     } catch (std::out_of_range& e) {
53905       {
53906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53907       };
53908     } catch (std::exception& e) {
53909       {
53910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53911       };
53912     } catch (Dali::DaliException e) {
53913       {
53914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53915       };
53916     } catch (...) {
53917       {
53918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53919       };
53920     }
53921   }
53922
53923 }
53924
53925
53926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
53927   void * jresult ;
53928   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
53929
53930   {
53931     try {
53932       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
53933     } catch (std::out_of_range& e) {
53934       {
53935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53936       };
53937     } catch (std::exception& e) {
53938       {
53939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53940       };
53941     } catch (Dali::DaliException e) {
53942       {
53943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53944       };
53945     } catch (...) {
53946       {
53947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53948       };
53949     }
53950   }
53951
53952   jresult = (void *)result;
53953   return jresult;
53954 }
53955
53956
53957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
53958   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53959
53960   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53961   {
53962     try {
53963       delete arg1;
53964     } catch (std::out_of_range& e) {
53965       {
53966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53967       };
53968     } catch (std::exception& e) {
53969       {
53970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53971       };
53972     } catch (Dali::DaliException e) {
53973       {
53974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53975       };
53976     } catch (...) {
53977       {
53978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53979       };
53980     }
53981   }
53982
53983 }
53984
53985
53986 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
53987   unsigned int jresult ;
53988   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53989   bool result;
53990
53991   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53992   {
53993     try {
53994       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);
53995     } catch (std::out_of_range& e) {
53996       {
53997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53998       };
53999     } catch (std::exception& e) {
54000       {
54001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54002       };
54003     } catch (Dali::DaliException e) {
54004       {
54005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54006       };
54007     } catch (...) {
54008       {
54009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54010       };
54011     }
54012   }
54013
54014   jresult = result;
54015   return jresult;
54016 }
54017
54018
54019 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54020   unsigned long jresult ;
54021   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54022   std::size_t result;
54023
54024   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54025   {
54026     try {
54027       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);
54028     } catch (std::out_of_range& e) {
54029       {
54030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54031       };
54032     } catch (std::exception& e) {
54033       {
54034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54035       };
54036     } catch (Dali::DaliException e) {
54037       {
54038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54039       };
54040     } catch (...) {
54041       {
54042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54043       };
54044     }
54045   }
54046
54047   jresult = (unsigned long)result;
54048   return jresult;
54049 }
54050
54051
54052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54053   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54054   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54055
54056   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54057   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54058   {
54059     try {
54060       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54061     } catch (std::out_of_range& e) {
54062       {
54063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54064       };
54065     } catch (std::exception& e) {
54066       {
54067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54068       };
54069     } catch (Dali::DaliException e) {
54070       {
54071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54072       };
54073     } catch (...) {
54074       {
54075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54076       };
54077     }
54078   }
54079
54080 }
54081
54082
54083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54084   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54085   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54086
54087   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54088   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54089   {
54090     try {
54091       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54092     } catch (std::out_of_range& e) {
54093       {
54094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54095       };
54096     } catch (std::exception& e) {
54097       {
54098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54099       };
54100     } catch (Dali::DaliException e) {
54101       {
54102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54103       };
54104     } catch (...) {
54105       {
54106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54107       };
54108     }
54109   }
54110
54111 }
54112
54113
54114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54115   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54116   Dali::Actor arg2 ;
54117   Dali::TapGesture *arg3 = 0 ;
54118   Dali::Actor *argp2 ;
54119
54120   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54121   argp2 = (Dali::Actor *)jarg2;
54122   if (!argp2) {
54123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54124     return ;
54125   }
54126   arg2 = *argp2;
54127   arg3 = (Dali::TapGesture *)jarg3;
54128   if (!arg3) {
54129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
54130     return ;
54131   }
54132   {
54133     try {
54134       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
54135     } catch (std::out_of_range& e) {
54136       {
54137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54138       };
54139     } catch (std::exception& e) {
54140       {
54141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54142       };
54143     } catch (Dali::DaliException e) {
54144       {
54145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54146       };
54147     } catch (...) {
54148       {
54149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54150       };
54151     }
54152   }
54153
54154 }
54155
54156
54157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
54158   void * jresult ;
54159   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
54160
54161   {
54162     try {
54163       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
54164     } catch (std::out_of_range& e) {
54165       {
54166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54167       };
54168     } catch (std::exception& e) {
54169       {
54170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54171       };
54172     } catch (Dali::DaliException e) {
54173       {
54174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54175       };
54176     } catch (...) {
54177       {
54178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54179       };
54180     }
54181   }
54182
54183   jresult = (void *)result;
54184   return jresult;
54185 }
54186
54187
54188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
54189   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54190
54191   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54192   {
54193     try {
54194       delete arg1;
54195     } catch (std::out_of_range& e) {
54196       {
54197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54198       };
54199     } catch (std::exception& e) {
54200       {
54201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54202       };
54203     } catch (Dali::DaliException e) {
54204       {
54205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54206       };
54207     } catch (...) {
54208       {
54209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54210       };
54211     }
54212   }
54213
54214 }
54215
54216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
54217   unsigned int jresult ;
54218   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54219   bool result = false;
54220
54221   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54222   {
54223     try {
54224       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);
54225     } catch (std::out_of_range& e) {
54226       {
54227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54228       };
54229     } catch (std::exception& e) {
54230       {
54231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54232       };
54233     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54234   }
54235   jresult = result;
54236   return jresult;
54237 }
54238
54239 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
54240   unsigned long jresult ;
54241   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54242   std::size_t result = 0;
54243
54244   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54245   {
54246     try {
54247       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);
54248     } catch (std::out_of_range& e) {
54249       {
54250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54251       };
54252     } catch (std::exception& e) {
54253       {
54254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54255       };
54256     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54257   }
54258   jresult = (unsigned long)result;
54259   return jresult;
54260 }
54261
54262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
54263   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54264   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54265
54266   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54267   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54268   {
54269     try {
54270       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
54271     } catch (std::out_of_range& e) {
54272       {
54273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54274       };
54275     } catch (std::exception& e) {
54276       {
54277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54278       };
54279     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54280   }
54281 }
54282
54283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
54284   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54285   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54286
54287   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54288   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54289   {
54290     try {
54291       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
54292     } catch (std::out_of_range& e) {
54293       {
54294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54295       };
54296     } catch (std::exception& e) {
54297       {
54298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54299       };
54300     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54301   }
54302 }
54303
54304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
54305   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54306   Dali::Actor arg2 ;
54307   //bool arg3 ;
54308   Dali::LayoutDirection::Type arg4 ;
54309   Dali::Actor *argp2 ;
54310
54311   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54312   argp2 = (Dali::Actor *)jarg2;
54313   if (!argp2) {
54314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54315     return ;
54316   }
54317   arg2 = *argp2;
54318   //arg3 = jarg3 ? true : false;
54319   arg4 = (Dali::LayoutDirection::Type)jarg4;
54320   {
54321     try {
54322       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
54323     } catch (std::out_of_range& e) {
54324       {
54325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54326       };
54327     } catch (std::exception& e) {
54328       {
54329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54330       };
54331     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54332   }
54333 }
54334
54335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
54336   void * jresult ;
54337   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
54338
54339   {
54340     try {
54341       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
54342     } catch (std::out_of_range& e) {
54343       {
54344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54345       };
54346     } catch (std::exception& e) {
54347       {
54348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54349       };
54350     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54351   }
54352   jresult = (void *)result;
54353   return jresult;
54354 }
54355
54356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
54357   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54358
54359   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54360   {
54361     try {
54362       delete arg1;
54363     } catch (std::out_of_range& e) {
54364       {
54365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54366       };
54367     } catch (std::exception& e) {
54368       {
54369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54370       };
54371     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54372   }
54373 }
54374
54375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
54376   unsigned int jresult ;
54377   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54378   bool result;
54379
54380   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54381   {
54382     try {
54383       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);
54384     } catch (std::out_of_range& e) {
54385       {
54386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54387       };
54388     } catch (std::exception& e) {
54389       {
54390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54391       };
54392     } catch (Dali::DaliException e) {
54393       {
54394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54395       };
54396     } catch (...) {
54397       {
54398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54399       };
54400     }
54401   }
54402
54403   jresult = result;
54404   return jresult;
54405 }
54406
54407
54408 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
54409   unsigned long jresult ;
54410   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54411   std::size_t result;
54412
54413   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54414   {
54415     try {
54416       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);
54417     } catch (std::out_of_range& e) {
54418       {
54419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54420       };
54421     } catch (std::exception& e) {
54422       {
54423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54424       };
54425     } catch (Dali::DaliException e) {
54426       {
54427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54428       };
54429     } catch (...) {
54430       {
54431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54432       };
54433     }
54434   }
54435
54436   jresult = (unsigned long)result;
54437   return jresult;
54438 }
54439
54440
54441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
54442   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54443   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54444
54445   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54446   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54447   {
54448     try {
54449       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
54450     } catch (std::out_of_range& e) {
54451       {
54452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54453       };
54454     } catch (std::exception& e) {
54455       {
54456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54457       };
54458     } catch (Dali::DaliException e) {
54459       {
54460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54461       };
54462     } catch (...) {
54463       {
54464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54465       };
54466     }
54467   }
54468
54469 }
54470
54471
54472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54473   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54474   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54475
54476   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54477   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54478   {
54479     try {
54480       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
54481     } catch (std::out_of_range& e) {
54482       {
54483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54484       };
54485     } catch (std::exception& e) {
54486       {
54487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54488       };
54489     } catch (Dali::DaliException e) {
54490       {
54491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54492       };
54493     } catch (...) {
54494       {
54495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54496       };
54497     }
54498   }
54499
54500 }
54501
54502
54503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
54504   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54505   Dali::Actor arg2 ;
54506   bool arg3 ;
54507   Dali::DevelActor::VisibilityChange::Type arg4 ;
54508   Dali::Actor *argp2 ;
54509
54510   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54511   argp2 = (Dali::Actor *)jarg2;
54512   if (!argp2) {
54513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54514     return ;
54515   }
54516   arg2 = *argp2;
54517   arg3 = jarg3 ? true : false;
54518   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
54519   {
54520     try {
54521       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54522     } catch (std::out_of_range& e) {
54523       {
54524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54525       };
54526     } catch (std::exception& e) {
54527       {
54528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54529       };
54530     } catch (Dali::DaliException e) {
54531       {
54532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54533       };
54534     } catch (...) {
54535       {
54536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54537       };
54538     }
54539   }
54540
54541 }
54542
54543
54544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
54545   void * jresult ;
54546   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
54547
54548   {
54549     try {
54550       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
54551     } catch (std::out_of_range& e) {
54552       {
54553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54554       };
54555     } catch (std::exception& e) {
54556       {
54557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54558       };
54559     } catch (Dali::DaliException e) {
54560       {
54561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54562       };
54563     } catch (...) {
54564       {
54565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54566       };
54567     }
54568   }
54569
54570   jresult = (void *)result;
54571   return jresult;
54572 }
54573
54574
54575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
54576   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54577
54578   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54579   {
54580     try {
54581       delete arg1;
54582     } catch (std::out_of_range& e) {
54583       {
54584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54585       };
54586     } catch (std::exception& e) {
54587       {
54588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54589       };
54590     } catch (Dali::DaliException e) {
54591       {
54592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54593       };
54594     } catch (...) {
54595       {
54596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54597       };
54598     }
54599   }
54600
54601 }
54602
54603
54604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
54605   void * jresult ;
54606   Dali::Timer *result = 0 ;
54607
54608   {
54609     try {
54610       result = (Dali::Timer *)new Dali::Timer();
54611     } catch (std::out_of_range& e) {
54612       {
54613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54614       };
54615     } catch (std::exception& e) {
54616       {
54617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54618       };
54619     } catch (Dali::DaliException e) {
54620       {
54621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54622       };
54623     } catch (...) {
54624       {
54625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54626       };
54627     }
54628   }
54629
54630   jresult = (void *)result;
54631   return jresult;
54632 }
54633
54634
54635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
54636   void * jresult ;
54637   unsigned int arg1 ;
54638   Dali::Timer result;
54639
54640   arg1 = (unsigned int)jarg1;
54641   {
54642     try {
54643       result = Dali::Timer::New(arg1);
54644     } catch (std::out_of_range& e) {
54645       {
54646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54647       };
54648     } catch (std::exception& e) {
54649       {
54650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54651       };
54652     } catch (Dali::DaliException e) {
54653       {
54654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54655       };
54656     } catch (...) {
54657       {
54658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54659       };
54660     }
54661   }
54662
54663   jresult = new Dali::Timer((const Dali::Timer &)result);
54664   return jresult;
54665 }
54666
54667
54668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
54669   void * jresult ;
54670   Dali::Timer *arg1 = 0 ;
54671   Dali::Timer *result = 0 ;
54672
54673   arg1 = (Dali::Timer *)jarg1;
54674   if (!arg1) {
54675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54676     return 0;
54677   }
54678   {
54679     try {
54680       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
54681     } catch (std::out_of_range& e) {
54682       {
54683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54684       };
54685     } catch (std::exception& e) {
54686       {
54687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54688       };
54689     } catch (Dali::DaliException e) {
54690       {
54691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54692       };
54693     } catch (...) {
54694       {
54695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54696       };
54697     }
54698   }
54699
54700   jresult = (void *)result;
54701   return jresult;
54702 }
54703
54704
54705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
54706   void * jresult ;
54707   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54708   Dali::Timer *arg2 = 0 ;
54709   Dali::Timer *result = 0 ;
54710
54711   arg1 = (Dali::Timer *)jarg1;
54712   arg2 = (Dali::Timer *)jarg2;
54713   if (!arg2) {
54714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54715     return 0;
54716   }
54717   {
54718     try {
54719       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
54720     } catch (std::out_of_range& e) {
54721       {
54722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54723       };
54724     } catch (std::exception& e) {
54725       {
54726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54727       };
54728     } catch (Dali::DaliException e) {
54729       {
54730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54731       };
54732     } catch (...) {
54733       {
54734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54735       };
54736     }
54737   }
54738
54739   jresult = (void *)result;
54740   return jresult;
54741 }
54742
54743
54744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
54745   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54746
54747   arg1 = (Dali::Timer *)jarg1;
54748   {
54749     try {
54750       delete arg1;
54751     } catch (std::out_of_range& e) {
54752       {
54753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54754       };
54755     } catch (std::exception& e) {
54756       {
54757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54758       };
54759     } catch (Dali::DaliException e) {
54760       {
54761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54762       };
54763     } catch (...) {
54764       {
54765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54766       };
54767     }
54768   }
54769
54770 }
54771
54772
54773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
54774   void * jresult ;
54775   Dali::BaseHandle arg1 ;
54776   Dali::BaseHandle *argp1 ;
54777   Dali::Timer result;
54778
54779   argp1 = (Dali::BaseHandle *)jarg1;
54780   if (!argp1) {
54781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54782     return 0;
54783   }
54784   arg1 = *argp1;
54785   {
54786     try {
54787       result = Dali::Timer::DownCast(arg1);
54788     } catch (std::out_of_range& e) {
54789       {
54790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54791       };
54792     } catch (std::exception& e) {
54793       {
54794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54795       };
54796     } catch (Dali::DaliException e) {
54797       {
54798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54799       };
54800     } catch (...) {
54801       {
54802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54803       };
54804     }
54805   }
54806
54807   jresult = new Dali::Timer((const Dali::Timer &)result);
54808   return jresult;
54809 }
54810
54811
54812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
54813   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54814
54815   arg1 = (Dali::Timer *)jarg1;
54816   {
54817     try {
54818       (arg1)->Start();
54819     } catch (std::out_of_range& e) {
54820       {
54821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54822       };
54823     } catch (std::exception& e) {
54824       {
54825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54826       };
54827     } catch (Dali::DaliException e) {
54828       {
54829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54830       };
54831     } catch (...) {
54832       {
54833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54834       };
54835     }
54836   }
54837
54838 }
54839
54840
54841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
54842   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54843
54844   arg1 = (Dali::Timer *)jarg1;
54845   {
54846     try {
54847       (arg1)->Stop();
54848     } catch (std::out_of_range& e) {
54849       {
54850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54851       };
54852     } catch (std::exception& e) {
54853       {
54854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54855       };
54856     } catch (Dali::DaliException e) {
54857       {
54858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54859       };
54860     } catch (...) {
54861       {
54862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54863       };
54864     }
54865   }
54866
54867 }
54868
54869
54870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
54871   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54872   unsigned int arg2 ;
54873
54874   arg1 = (Dali::Timer *)jarg1;
54875   arg2 = (unsigned int)jarg2;
54876   {
54877     try {
54878       (arg1)->SetInterval(arg2);
54879     } catch (std::out_of_range& e) {
54880       {
54881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54882       };
54883     } catch (std::exception& e) {
54884       {
54885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54886       };
54887     } catch (Dali::DaliException e) {
54888       {
54889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54890       };
54891     } catch (...) {
54892       {
54893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54894       };
54895     }
54896   }
54897
54898 }
54899
54900
54901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
54902   unsigned int jresult ;
54903   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54904   unsigned int result;
54905
54906   arg1 = (Dali::Timer *)jarg1;
54907   {
54908     try {
54909       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
54910     } catch (std::out_of_range& e) {
54911       {
54912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54913       };
54914     } catch (std::exception& e) {
54915       {
54916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54917       };
54918     } catch (Dali::DaliException e) {
54919       {
54920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54921       };
54922     } catch (...) {
54923       {
54924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54925       };
54926     }
54927   }
54928
54929   jresult = result;
54930   return jresult;
54931 }
54932
54933
54934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
54935   unsigned int jresult ;
54936   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54937   bool result;
54938
54939   arg1 = (Dali::Timer *)jarg1;
54940   {
54941     try {
54942       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
54943     } catch (std::out_of_range& e) {
54944       {
54945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54946       };
54947     } catch (std::exception& e) {
54948       {
54949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54950       };
54951     } catch (Dali::DaliException e) {
54952       {
54953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54954       };
54955     } catch (...) {
54956       {
54957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54958       };
54959     }
54960   }
54961
54962   jresult = result;
54963   return jresult;
54964 }
54965
54966
54967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
54968   void * jresult ;
54969   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54970   Dali::Timer::TimerSignalType *result = 0 ;
54971
54972   arg1 = (Dali::Timer *)jarg1;
54973   {
54974     try {
54975       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
54976     } catch (std::out_of_range& e) {
54977       {
54978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54979       };
54980     } catch (std::exception& e) {
54981       {
54982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54983       };
54984     } catch (Dali::DaliException e) {
54985       {
54986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54987       };
54988     } catch (...) {
54989       {
54990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54991       };
54992     }
54993   }
54994
54995   jresult = (void *)result;
54996   return jresult;
54997 }
54998
54999
55000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55001   unsigned int jresult ;
55002   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55003   bool result;
55004
55005   arg1 = (Dali::Signal< bool () > *)jarg1;
55006   {
55007     try {
55008       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
55009     } catch (std::out_of_range& e) {
55010       {
55011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55012       };
55013     } catch (std::exception& e) {
55014       {
55015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55016       };
55017     } catch (Dali::DaliException e) {
55018       {
55019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55020       };
55021     } catch (...) {
55022       {
55023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55024       };
55025     }
55026   }
55027
55028   jresult = result;
55029   return jresult;
55030 }
55031
55032
55033 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55034   unsigned long jresult ;
55035   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55036   std::size_t result;
55037
55038   arg1 = (Dali::Signal< bool () > *)jarg1;
55039   {
55040     try {
55041       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
55042     } catch (std::out_of_range& e) {
55043       {
55044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55045       };
55046     } catch (std::exception& e) {
55047       {
55048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55049       };
55050     } catch (Dali::DaliException e) {
55051       {
55052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55053       };
55054     } catch (...) {
55055       {
55056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55057       };
55058     }
55059   }
55060
55061   jresult = (unsigned long)result;
55062   return jresult;
55063 }
55064
55065
55066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
55067   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55068   bool (*arg2)() = (bool (*)()) 0 ;
55069
55070   arg1 = (Dali::Signal< bool () > *)jarg1;
55071   arg2 = (bool (*)())jarg2;
55072   {
55073     try {
55074       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
55075     } catch (std::out_of_range& e) {
55076       {
55077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55078       };
55079     } catch (std::exception& e) {
55080       {
55081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55082       };
55083     } catch (Dali::DaliException e) {
55084       {
55085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55086       };
55087     } catch (...) {
55088       {
55089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55090       };
55091     }
55092   }
55093
55094 }
55095
55096
55097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55098   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55099   bool (*arg2)() = (bool (*)()) 0 ;
55100
55101   arg1 = (Dali::Signal< bool () > *)jarg1;
55102   arg2 = (bool (*)())jarg2;
55103   {
55104     try {
55105       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55106     } catch (std::out_of_range& e) {
55107       {
55108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55109       };
55110     } catch (std::exception& e) {
55111       {
55112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55113       };
55114     } catch (Dali::DaliException e) {
55115       {
55116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55117       };
55118     } catch (...) {
55119       {
55120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55121       };
55122     }
55123   }
55124
55125 }
55126
55127
55128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55129   unsigned int jresult ;
55130   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55131   bool result;
55132
55133   arg1 = (Dali::Signal< bool () > *)jarg1;
55134   {
55135     try {
55136       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55137     } catch (std::out_of_range& e) {
55138       {
55139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55140       };
55141     } catch (std::exception& e) {
55142       {
55143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55144       };
55145     } catch (Dali::DaliException e) {
55146       {
55147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55148       };
55149     } catch (...) {
55150       {
55151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55152       };
55153     }
55154   }
55155
55156   jresult = result;
55157   return jresult;
55158 }
55159
55160
55161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55162   void * jresult ;
55163   Dali::Signal< bool () > *result = 0 ;
55164
55165   {
55166     try {
55167       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55168     } catch (std::out_of_range& e) {
55169       {
55170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55171       };
55172     } catch (std::exception& e) {
55173       {
55174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55175       };
55176     } catch (Dali::DaliException e) {
55177       {
55178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55179       };
55180     } catch (...) {
55181       {
55182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55183       };
55184     }
55185   }
55186
55187   jresult = (void *)result;
55188   return jresult;
55189 }
55190
55191
55192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55193   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55194
55195   arg1 = (Dali::Signal< bool () > *)jarg1;
55196   {
55197     try {
55198       delete arg1;
55199     } catch (std::out_of_range& e) {
55200       {
55201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55202       };
55203     } catch (std::exception& e) {
55204       {
55205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55206       };
55207     } catch (Dali::DaliException e) {
55208       {
55209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55210       };
55211     } catch (...) {
55212       {
55213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55214       };
55215     }
55216   }
55217
55218 }
55219
55220
55221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55222   int jresult ;
55223   int result;
55224
55225   {
55226     try {
55227       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55228     } catch (std::out_of_range& e) {
55229       {
55230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55231       };
55232     } catch (std::exception& e) {
55233       {
55234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55235       };
55236     } catch (Dali::DaliException e) {
55237       {
55238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55239       };
55240     } catch (...) {
55241       {
55242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55243       };
55244     }
55245   }
55246
55247   jresult = (int)result;
55248   return jresult;
55249 }
55250
55251
55252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55253   int jresult ;
55254   int result;
55255
55256   {
55257     try {
55258       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55259     } catch (std::out_of_range& e) {
55260       {
55261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55262       };
55263     } catch (std::exception& e) {
55264       {
55265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55266       };
55267     } catch (Dali::DaliException e) {
55268       {
55269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55270       };
55271     } catch (...) {
55272       {
55273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55274       };
55275     }
55276   }
55277
55278   jresult = (int)result;
55279   return jresult;
55280 }
55281
55282
55283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55284   int jresult ;
55285   int result;
55286
55287   {
55288     try {
55289       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55290     } catch (std::out_of_range& e) {
55291       {
55292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55293       };
55294     } catch (std::exception& e) {
55295       {
55296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55297       };
55298     } catch (Dali::DaliException e) {
55299       {
55300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55301       };
55302     } catch (...) {
55303       {
55304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55305       };
55306     }
55307   }
55308
55309   jresult = (int)result;
55310   return jresult;
55311 }
55312
55313
55314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55315   int jresult ;
55316   int result;
55317
55318   {
55319     try {
55320       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55321     } catch (std::out_of_range& e) {
55322       {
55323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55324       };
55325     } catch (std::exception& e) {
55326       {
55327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55328       };
55329     } catch (Dali::DaliException e) {
55330       {
55331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55332       };
55333     } catch (...) {
55334       {
55335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55336       };
55337     }
55338   }
55339
55340   jresult = (int)result;
55341   return jresult;
55342 }
55343
55344
55345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55346   int jresult ;
55347   int result;
55348
55349   {
55350     try {
55351       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55352     } catch (std::out_of_range& e) {
55353       {
55354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55355       };
55356     } catch (std::exception& e) {
55357       {
55358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55359       };
55360     } catch (Dali::DaliException e) {
55361       {
55362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55363       };
55364     } catch (...) {
55365       {
55366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55367       };
55368     }
55369   }
55370
55371   jresult = (int)result;
55372   return jresult;
55373 }
55374
55375
55376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55377   int jresult ;
55378   int result;
55379
55380   {
55381     try {
55382       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55383     } catch (std::out_of_range& e) {
55384       {
55385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55386       };
55387     } catch (std::exception& e) {
55388       {
55389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55390       };
55391     } catch (Dali::DaliException e) {
55392       {
55393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55394       };
55395     } catch (...) {
55396       {
55397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55398       };
55399     }
55400   }
55401
55402   jresult = (int)result;
55403   return jresult;
55404 }
55405
55406
55407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55408   int jresult ;
55409   int result;
55410
55411   {
55412     try {
55413       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55414     } catch (std::out_of_range& e) {
55415       {
55416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55417       };
55418     } catch (std::exception& e) {
55419       {
55420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55421       };
55422     } catch (Dali::DaliException e) {
55423       {
55424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55425       };
55426     } catch (...) {
55427       {
55428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55429       };
55430     }
55431   }
55432
55433   jresult = (int)result;
55434   return jresult;
55435 }
55436
55437
55438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55439   int jresult ;
55440   int result;
55441
55442   {
55443     try {
55444       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55445     } catch (std::out_of_range& e) {
55446       {
55447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55448       };
55449     } catch (std::exception& e) {
55450       {
55451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55452       };
55453     } catch (Dali::DaliException e) {
55454       {
55455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55456       };
55457     } catch (...) {
55458       {
55459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55460       };
55461     }
55462   }
55463
55464   jresult = (int)result;
55465   return jresult;
55466 }
55467
55468
55469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55470   int jresult ;
55471   int result;
55472
55473   {
55474     try {
55475       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55476     } catch (std::out_of_range& e) {
55477       {
55478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55479       };
55480     } catch (std::exception& e) {
55481       {
55482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55483       };
55484     } catch (Dali::DaliException e) {
55485       {
55486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55487       };
55488     } catch (...) {
55489       {
55490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55491       };
55492     }
55493   }
55494
55495   jresult = (int)result;
55496   return jresult;
55497 }
55498
55499
55500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
55501   int jresult ;
55502   int result;
55503
55504   {
55505     try {
55506       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55507     } catch (std::out_of_range& e) {
55508       {
55509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55510       };
55511     } catch (std::exception& e) {
55512       {
55513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55514       };
55515     } catch (Dali::DaliException e) {
55516       {
55517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55518       };
55519     } catch (...) {
55520       {
55521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55522       };
55523     }
55524   }
55525
55526   jresult = (int)result;
55527   return jresult;
55528 }
55529
55530
55531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
55532   int jresult ;
55533   int result;
55534
55535   {
55536     try {
55537       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
55538     } catch (std::out_of_range& e) {
55539       {
55540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55541       };
55542     } catch (std::exception& e) {
55543       {
55544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55545       };
55546     } catch (Dali::DaliException e) {
55547       {
55548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55549       };
55550     } catch (...) {
55551       {
55552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55553       };
55554     }
55555   }
55556
55557   jresult = (int)result;
55558   return jresult;
55559 }
55560
55561
55562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
55563   int jresult ;
55564   int result;
55565
55566   {
55567     try {
55568       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
55569     } catch (std::out_of_range& e) {
55570       {
55571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55572       };
55573     } catch (std::exception& e) {
55574       {
55575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55576       };
55577     } catch (Dali::DaliException e) {
55578       {
55579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55580       };
55581     } catch (...) {
55582       {
55583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55584       };
55585     }
55586   }
55587
55588   jresult = (int)result;
55589   return jresult;
55590 }
55591
55592
55593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
55594   int jresult ;
55595   int result;
55596
55597   {
55598     try {
55599       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
55600     } catch (std::out_of_range& e) {
55601       {
55602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55603       };
55604     } catch (std::exception& e) {
55605       {
55606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55607       };
55608     } catch (Dali::DaliException e) {
55609       {
55610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55611       };
55612     } catch (...) {
55613       {
55614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55615       };
55616     }
55617   }
55618
55619   jresult = (int)result;
55620   return jresult;
55621 }
55622
55623
55624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
55625   int jresult ;
55626   int result;
55627
55628   {
55629     try {
55630       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
55631     } catch (std::out_of_range& e) {
55632       {
55633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55634       };
55635     } catch (std::exception& e) {
55636       {
55637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55638       };
55639     } catch (Dali::DaliException e) {
55640       {
55641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55642       };
55643     } catch (...) {
55644       {
55645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55646       };
55647     }
55648   }
55649
55650   jresult = (int)result;
55651   return jresult;
55652 }
55653
55654
55655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
55656   int jresult ;
55657   int result;
55658
55659   {
55660     try {
55661       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
55662     } catch (std::out_of_range& e) {
55663       {
55664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55665       };
55666     } catch (std::exception& e) {
55667       {
55668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55669       };
55670     } catch (Dali::DaliException e) {
55671       {
55672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55673       };
55674     } catch (...) {
55675       {
55676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55677       };
55678     }
55679   }
55680
55681   jresult = (int)result;
55682   return jresult;
55683 }
55684
55685
55686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
55687   int jresult ;
55688   int result;
55689
55690   {
55691     try {
55692       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
55693     } catch (std::out_of_range& e) {
55694       {
55695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55696       };
55697     } catch (std::exception& e) {
55698       {
55699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55700       };
55701     } catch (Dali::DaliException e) {
55702       {
55703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55704       };
55705     } catch (...) {
55706       {
55707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55708       };
55709     }
55710   }
55711
55712   jresult = (int)result;
55713   return jresult;
55714 }
55715
55716
55717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
55718   int jresult ;
55719   int result;
55720
55721   {
55722     try {
55723       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
55724     } catch (std::out_of_range& e) {
55725       {
55726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55727       };
55728     } catch (std::exception& e) {
55729       {
55730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55731       };
55732     } catch (Dali::DaliException e) {
55733       {
55734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55735       };
55736     } catch (...) {
55737       {
55738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55739       };
55740     }
55741   }
55742
55743   jresult = (int)result;
55744   return jresult;
55745 }
55746
55747
55748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
55749   int jresult ;
55750   int result;
55751
55752   {
55753     try {
55754       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
55755     } catch (std::out_of_range& e) {
55756       {
55757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55758       };
55759     } catch (std::exception& e) {
55760       {
55761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55762       };
55763     } catch (Dali::DaliException e) {
55764       {
55765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55766       };
55767     } catch (...) {
55768       {
55769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55770       };
55771     }
55772   }
55773
55774   jresult = (int)result;
55775   return jresult;
55776 }
55777
55778
55779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
55780   int jresult ;
55781   int result;
55782
55783   {
55784     try {
55785       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
55786     } catch (std::out_of_range& e) {
55787       {
55788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55789       };
55790     } catch (std::exception& e) {
55791       {
55792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55793       };
55794     } catch (Dali::DaliException e) {
55795       {
55796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55797       };
55798     } catch (...) {
55799       {
55800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55801       };
55802     }
55803   }
55804
55805   jresult = (int)result;
55806   return jresult;
55807 }
55808
55809
55810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
55811   int jresult ;
55812   int result;
55813
55814   {
55815     try {
55816       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
55817     } catch (std::out_of_range& e) {
55818       {
55819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55820       };
55821     } catch (std::exception& e) {
55822       {
55823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55824       };
55825     } catch (Dali::DaliException e) {
55826       {
55827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55828       };
55829     } catch (...) {
55830       {
55831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55832       };
55833     }
55834   }
55835
55836   jresult = (int)result;
55837   return jresult;
55838 }
55839
55840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
55841   int jresult ;
55842   int result;
55843
55844   {
55845     try {
55846       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
55847     } catch (std::out_of_range& e) {
55848       {
55849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55850       };
55851     } catch (std::exception& e) {
55852       {
55853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55854       };
55855     } catch (Dali::DaliException e) {
55856       {
55857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55858       };
55859     } catch (...) {
55860       {
55861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55862       };
55863     }
55864   }
55865
55866   jresult = (int)result;
55867   return jresult;
55868 }
55869
55870
55871 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
55872   int jresult ;
55873   int result;
55874   {
55875     try
55876     {
55877       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
55878     } catch (std::out_of_range& e) {
55879       {
55880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55881       };
55882     } catch (std::exception& e) {
55883       {
55884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55885       };
55886     } catch (Dali::DaliException e) {
55887       {
55888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55889       };
55890     } catch (...) {
55891       {
55892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55893       };
55894     }
55895   }
55896
55897   jresult = (int)result;
55898   return jresult;
55899 }
55900
55901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
55902   int jresult ;
55903   int result;
55904   {
55905     try
55906     {
55907       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
55908     } catch (std::out_of_range& e) {
55909       {
55910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55911       };
55912     } catch (std::exception& e) {
55913       {
55914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55915       };
55916     } catch (Dali::DaliException e) {
55917       {
55918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55919       };
55920     } catch (...) {
55921       {
55922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55923       };
55924     }
55925   }
55926
55927   jresult = (int)result;
55928   return jresult;
55929 }
55930
55931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
55932   int jresult ;
55933   int result;
55934   {
55935     try
55936     {
55937       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
55938     } catch (std::out_of_range& e) {
55939       {
55940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55941       };
55942     } catch (std::exception& e) {
55943       {
55944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55945       };
55946     } catch (Dali::DaliException e) {
55947       {
55948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55949       };
55950     } catch (...) {
55951       {
55952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55953       };
55954     }
55955   }
55956
55957   jresult = (int)result;
55958   return jresult;
55959 }
55960
55961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
55962   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
55963 }
55964
55965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
55966   int jresult ;
55967   int result;
55968   {
55969     try
55970     {
55971       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
55972     } catch (std::out_of_range& e) {
55973       {
55974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55975       };
55976     } catch (std::exception& e) {
55977       {
55978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55979       };
55980     } catch (Dali::DaliException e) {
55981       {
55982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55983       };
55984     } catch (...) {
55985       {
55986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55987       };
55988     }
55989   }
55990
55991   jresult = (int)result;
55992   return jresult;
55993 }
55994
55995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
55996   int jresult ;
55997   int result;
55998   {
55999     try
56000     {
56001       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
56002     } catch (std::out_of_range& e) {
56003       {
56004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56005       };
56006     } catch (std::exception& e) {
56007       {
56008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56009       };
56010     } catch (Dali::DaliException e) {
56011       {
56012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56013       };
56014     } catch (...) {
56015       {
56016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56017       };
56018     }
56019   }
56020
56021   jresult = (int)result;
56022   return jresult;
56023 }
56024
56025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
56026   int jresult ;
56027   int result;
56028
56029   {
56030     try {
56031       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
56032     } catch (std::out_of_range& e) {
56033       {
56034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56035       };
56036     } catch (std::exception& e) {
56037       {
56038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56039       };
56040     } catch (Dali::DaliException e) {
56041       {
56042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56043       };
56044     } catch (...) {
56045       {
56046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56047       };
56048     }
56049   }
56050
56051   jresult = (int)result;
56052   return jresult;
56053 }
56054
56055
56056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
56057   int jresult ;
56058   int result;
56059
56060   {
56061     try {
56062       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
56063     } catch (std::out_of_range& e) {
56064       {
56065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56066       };
56067     } catch (std::exception& e) {
56068       {
56069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56070       };
56071     } catch (Dali::DaliException e) {
56072       {
56073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56074       };
56075     } catch (...) {
56076       {
56077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56078       };
56079     }
56080   }
56081
56082   jresult = (int)result;
56083   return jresult;
56084 }
56085
56086 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
56087   int jresult ;
56088   int result;
56089   {
56090     try
56091     {
56092       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
56093     } catch (std::out_of_range& e) {
56094       {
56095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56096       };
56097     } catch (std::exception& e) {
56098       {
56099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56100       };
56101     } catch (...) {
56102       {
56103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56104       };
56105     }
56106   }
56107   jresult = (int)result;
56108   return jresult;
56109 }
56110
56111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
56112   int jresult ;
56113   int result;
56114   {
56115     try
56116     {
56117       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
56118     } catch (std::out_of_range& e) {
56119       {
56120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56121       };
56122     } catch (std::exception& e) {
56123       {
56124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56125       };
56126     } catch (...) {
56127       {
56128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56129       };
56130     }
56131   }
56132   jresult = (int)result;
56133   return jresult;
56134 }
56135
56136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
56137   int jresult ;
56138   int result;
56139   {
56140     try
56141     {
56142       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
56143     } catch (std::out_of_range& e) {
56144       {
56145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56146       };
56147     } catch (std::exception& e) {
56148       {
56149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56150       };
56151     } catch (...) {
56152       {
56153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56154       };
56155     }
56156   }
56157   jresult = (int)result;
56158   return jresult;
56159 }
56160
56161
56162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
56163   int jresult ;
56164   int result;
56165   {
56166     try
56167     {
56168       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
56169     } catch (std::out_of_range& e) {
56170       {
56171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56172       };
56173     } catch (std::exception& e) {
56174       {
56175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56176       };
56177     } catch (...) {
56178       {
56179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56180       };
56181     }
56182   }
56183   jresult = (int)result;
56184   return jresult;
56185 }
56186
56187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
56188   int jresult ;
56189   int result;
56190   {
56191     try
56192     {
56193       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
56194     } catch (std::out_of_range& e) {
56195       {
56196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56197       };
56198     } catch (std::exception& e) {
56199       {
56200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56201       };
56202     } catch (...) {
56203       {
56204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56205       };
56206     }
56207   }
56208   jresult = (int)result;
56209   return jresult;
56210 }
56211
56212
56213
56214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56215   int jresult ;
56216   int result;
56217
56218   {
56219     try {
56220       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56221     } catch (std::out_of_range& e) {
56222       {
56223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56224       };
56225     } catch (std::exception& e) {
56226       {
56227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56228       };
56229     } catch (Dali::DaliException e) {
56230       {
56231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56232       };
56233     } catch (...) {
56234       {
56235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56236       };
56237     }
56238   }
56239
56240   jresult = (int)result;
56241   return jresult;
56242 }
56243
56244
56245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56246   int jresult ;
56247   int result;
56248
56249   {
56250     try {
56251       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56252     } catch (std::out_of_range& e) {
56253       {
56254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56255       };
56256     } catch (std::exception& e) {
56257       {
56258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56259       };
56260     } catch (Dali::DaliException e) {
56261       {
56262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56263       };
56264     } catch (...) {
56265       {
56266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56267       };
56268     }
56269   }
56270
56271   jresult = (int)result;
56272   return jresult;
56273 }
56274
56275
56276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56277   int jresult ;
56278   int result;
56279
56280   {
56281     try {
56282       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56283     } catch (std::out_of_range& e) {
56284       {
56285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56286       };
56287     } catch (std::exception& e) {
56288       {
56289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56290       };
56291     } catch (Dali::DaliException e) {
56292       {
56293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56294       };
56295     } catch (...) {
56296       {
56297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56298       };
56299     }
56300   }
56301
56302   jresult = (int)result;
56303   return jresult;
56304 }
56305
56306
56307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56308   int jresult ;
56309   int result;
56310
56311   {
56312     try {
56313       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56314     } catch (std::out_of_range& e) {
56315       {
56316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56317       };
56318     } catch (std::exception& e) {
56319       {
56320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56321       };
56322     } catch (Dali::DaliException e) {
56323       {
56324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56325       };
56326     } catch (...) {
56327       {
56328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56329       };
56330     }
56331   }
56332
56333   jresult = (int)result;
56334   return jresult;
56335 }
56336
56337
56338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56339   int jresult ;
56340   int result;
56341
56342   {
56343     try {
56344       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56345     } catch (std::out_of_range& e) {
56346       {
56347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56348       };
56349     } catch (std::exception& e) {
56350       {
56351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56352       };
56353     } catch (Dali::DaliException e) {
56354       {
56355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56356       };
56357     } catch (...) {
56358       {
56359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56360       };
56361     }
56362   }
56363
56364   jresult = (int)result;
56365   return jresult;
56366 }
56367
56368
56369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56370   int jresult ;
56371   int result;
56372
56373   {
56374     try {
56375       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56376     } catch (std::out_of_range& e) {
56377       {
56378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56379       };
56380     } catch (std::exception& e) {
56381       {
56382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56383       };
56384     } catch (Dali::DaliException e) {
56385       {
56386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56387       };
56388     } catch (...) {
56389       {
56390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56391       };
56392     }
56393   }
56394
56395   jresult = (int)result;
56396   return jresult;
56397 }
56398
56399
56400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56401   int jresult ;
56402   int result;
56403
56404   {
56405     try {
56406       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56407     } catch (std::out_of_range& e) {
56408       {
56409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56410       };
56411     } catch (std::exception& e) {
56412       {
56413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56414       };
56415     } catch (Dali::DaliException e) {
56416       {
56417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56418       };
56419     } catch (...) {
56420       {
56421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56422       };
56423     }
56424   }
56425
56426   jresult = (int)result;
56427   return jresult;
56428 }
56429
56430 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
56431   int jresult ;
56432   int result;
56433
56434   {
56435     try {
56436       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
56437     } catch (std::out_of_range& e) {
56438       {
56439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56440       };
56441     } catch (std::exception& e) {
56442       {
56443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56444       };
56445     } catch (...) {
56446       {
56447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56448       };
56449     }
56450   }
56451   jresult = (int)result;
56452   return jresult;
56453 }
56454
56455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56456   int jresult ;
56457   int result;
56458
56459   {
56460     try {
56461       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56462     } catch (std::out_of_range& e) {
56463       {
56464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56465       };
56466     } catch (std::exception& e) {
56467       {
56468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56469       };
56470     } catch (Dali::DaliException e) {
56471       {
56472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56473       };
56474     } catch (...) {
56475       {
56476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56477       };
56478     }
56479   }
56480
56481   jresult = (int)result;
56482   return jresult;
56483 }
56484
56485
56486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56487   int jresult ;
56488   int result;
56489
56490   {
56491     try {
56492       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56493     } catch (std::out_of_range& e) {
56494       {
56495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56496       };
56497     } catch (std::exception& e) {
56498       {
56499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56500       };
56501     } catch (Dali::DaliException e) {
56502       {
56503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56504       };
56505     } catch (...) {
56506       {
56507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56508       };
56509     }
56510   }
56511
56512   jresult = (int)result;
56513   return jresult;
56514 }
56515
56516
56517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56518   int jresult ;
56519   int result;
56520
56521   {
56522     try {
56523       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56524     } catch (std::out_of_range& e) {
56525       {
56526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56527       };
56528     } catch (std::exception& e) {
56529       {
56530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56531       };
56532     } catch (Dali::DaliException e) {
56533       {
56534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56535       };
56536     } catch (...) {
56537       {
56538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56539       };
56540     }
56541   }
56542
56543   jresult = (int)result;
56544   return jresult;
56545 }
56546
56547
56548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56549   int jresult ;
56550   int result;
56551
56552   {
56553     try {
56554       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56555     } catch (std::out_of_range& e) {
56556       {
56557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56558       };
56559     } catch (std::exception& e) {
56560       {
56561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56562       };
56563     } catch (Dali::DaliException e) {
56564       {
56565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56566       };
56567     } catch (...) {
56568       {
56569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56570       };
56571     }
56572   }
56573
56574   jresult = (int)result;
56575   return jresult;
56576 }
56577
56578
56579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56580   int jresult ;
56581   int result;
56582
56583   {
56584     try {
56585       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56586     } catch (std::out_of_range& e) {
56587       {
56588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56589       };
56590     } catch (std::exception& e) {
56591       {
56592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56593       };
56594     } catch (Dali::DaliException e) {
56595       {
56596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56597       };
56598     } catch (...) {
56599       {
56600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56601       };
56602     }
56603   }
56604
56605   jresult = (int)result;
56606   return jresult;
56607 }
56608
56609
56610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56611   int jresult ;
56612   int result;
56613
56614   {
56615     try {
56616       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56617     } catch (std::out_of_range& e) {
56618       {
56619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56620       };
56621     } catch (std::exception& e) {
56622       {
56623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56624       };
56625     } catch (Dali::DaliException e) {
56626       {
56627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56628       };
56629     } catch (...) {
56630       {
56631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56632       };
56633     }
56634   }
56635
56636   jresult = (int)result;
56637   return jresult;
56638 }
56639
56640
56641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56642   int jresult ;
56643   int result;
56644
56645   {
56646     try {
56647       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56648     } catch (std::out_of_range& e) {
56649       {
56650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56651       };
56652     } catch (std::exception& e) {
56653       {
56654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56655       };
56656     } catch (Dali::DaliException e) {
56657       {
56658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56659       };
56660     } catch (...) {
56661       {
56662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56663       };
56664     }
56665   }
56666
56667   jresult = (int)result;
56668   return jresult;
56669 }
56670
56671
56672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56673   int jresult ;
56674   int result;
56675
56676   {
56677     try {
56678       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56679     } catch (std::out_of_range& e) {
56680       {
56681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56682       };
56683     } catch (std::exception& e) {
56684       {
56685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56686       };
56687     } catch (Dali::DaliException e) {
56688       {
56689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56690       };
56691     } catch (...) {
56692       {
56693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56694       };
56695     }
56696   }
56697
56698   jresult = (int)result;
56699   return jresult;
56700 }
56701
56702
56703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56704   int jresult ;
56705   int result;
56706
56707   {
56708     try {
56709       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56710     } catch (std::out_of_range& e) {
56711       {
56712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56713       };
56714     } catch (std::exception& e) {
56715       {
56716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56717       };
56718     } catch (Dali::DaliException e) {
56719       {
56720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56721       };
56722     } catch (...) {
56723       {
56724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56725       };
56726     }
56727   }
56728
56729   jresult = (int)result;
56730   return jresult;
56731 }
56732
56733
56734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56735   int jresult ;
56736   int result;
56737
56738   {
56739     try {
56740       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56741     } catch (std::out_of_range& e) {
56742       {
56743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56744       };
56745     } catch (std::exception& e) {
56746       {
56747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56748       };
56749     } catch (Dali::DaliException e) {
56750       {
56751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56752       };
56753     } catch (...) {
56754       {
56755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56756       };
56757     }
56758   }
56759
56760   jresult = (int)result;
56761   return jresult;
56762 }
56763
56764
56765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
56766   int jresult ;
56767   int result;
56768
56769   {
56770     try {
56771       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56772     } catch (std::out_of_range& e) {
56773       {
56774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56775       };
56776     } catch (std::exception& e) {
56777       {
56778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56779       };
56780     } catch (Dali::DaliException e) {
56781       {
56782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56783       };
56784     } catch (...) {
56785       {
56786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56787       };
56788     }
56789   }
56790
56791   jresult = (int)result;
56792   return jresult;
56793 }
56794
56795
56796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
56797   int jresult ;
56798   int result;
56799
56800   {
56801     try {
56802       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56803     } catch (std::out_of_range& e) {
56804       {
56805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56806       };
56807     } catch (std::exception& e) {
56808       {
56809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56810       };
56811     } catch (Dali::DaliException e) {
56812       {
56813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56814       };
56815     } catch (...) {
56816       {
56817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56818       };
56819     }
56820   }
56821
56822   jresult = (int)result;
56823   return jresult;
56824 }
56825
56826
56827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
56828   int jresult ;
56829   int result;
56830
56831   {
56832     try {
56833       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
56834     } catch (std::out_of_range& e) {
56835       {
56836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56837       };
56838     } catch (std::exception& e) {
56839       {
56840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56841       };
56842     } catch (Dali::DaliException e) {
56843       {
56844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56845       };
56846     } catch (...) {
56847       {
56848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56849       };
56850     }
56851   }
56852
56853   jresult = (int)result;
56854   return jresult;
56855 }
56856
56857
56858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
56859   int jresult ;
56860   int result;
56861
56862   {
56863     try {
56864       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
56865     } catch (std::out_of_range& e) {
56866       {
56867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56868       };
56869     } catch (std::exception& e) {
56870       {
56871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56872       };
56873     } catch (Dali::DaliException e) {
56874       {
56875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56876       };
56877     } catch (...) {
56878       {
56879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56880       };
56881     }
56882   }
56883
56884   jresult = (int)result;
56885   return jresult;
56886 }
56887
56888
56889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
56890   int jresult ;
56891   int result;
56892
56893   {
56894     try {
56895       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
56896     } catch (std::out_of_range& e) {
56897       {
56898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56899       };
56900     } catch (std::exception& e) {
56901       {
56902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56903       };
56904     } catch (Dali::DaliException e) {
56905       {
56906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56907       };
56908     } catch (...) {
56909       {
56910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56911       };
56912     }
56913   }
56914
56915   jresult = (int)result;
56916   return jresult;
56917 }
56918
56919
56920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
56921   int jresult ;
56922   int result;
56923
56924   {
56925     try {
56926       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
56927     } catch (std::out_of_range& e) {
56928       {
56929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56930       };
56931     } catch (std::exception& e) {
56932       {
56933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56934       };
56935     } catch (Dali::DaliException e) {
56936       {
56937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56938       };
56939     } catch (...) {
56940       {
56941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56942       };
56943     }
56944   }
56945
56946   jresult = (int)result;
56947   return jresult;
56948 }
56949
56950
56951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
56952   int jresult ;
56953   int result;
56954
56955   {
56956     try {
56957       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
56958     } catch (std::out_of_range& e) {
56959       {
56960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56961       };
56962     } catch (std::exception& e) {
56963       {
56964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56965       };
56966     } catch (Dali::DaliException e) {
56967       {
56968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56969       };
56970     } catch (...) {
56971       {
56972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56973       };
56974     }
56975   }
56976
56977   jresult = (int)result;
56978   return jresult;
56979 }
56980
56981
56982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
56983   int jresult ;
56984   int result;
56985
56986   {
56987     try {
56988       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
56989     } catch (std::out_of_range& e) {
56990       {
56991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56992       };
56993     } catch (std::exception& e) {
56994       {
56995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56996       };
56997     } catch (Dali::DaliException e) {
56998       {
56999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57000       };
57001     } catch (...) {
57002       {
57003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57004       };
57005     }
57006   }
57007
57008   jresult = (int)result;
57009   return jresult;
57010 }
57011
57012
57013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
57014   int jresult ;
57015   int result;
57016
57017   {
57018     try {
57019       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
57020     } catch (std::out_of_range& e) {
57021       {
57022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57023       };
57024     } catch (std::exception& e) {
57025       {
57026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57027       };
57028     } catch (Dali::DaliException e) {
57029       {
57030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57031       };
57032     } catch (...) {
57033       {
57034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57035       };
57036     }
57037   }
57038
57039   jresult = (int)result;
57040   return jresult;
57041 }
57042
57043
57044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
57045   int jresult ;
57046   int result;
57047
57048   {
57049     try {
57050       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
57051     } catch (std::out_of_range& e) {
57052       {
57053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57054       };
57055     } catch (std::exception& e) {
57056       {
57057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57058       };
57059     } catch (Dali::DaliException e) {
57060       {
57061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57062       };
57063     } catch (...) {
57064       {
57065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57066       };
57067     }
57068   }
57069
57070   jresult = (int)result;
57071   return jresult;
57072 }
57073
57074
57075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
57076   int jresult ;
57077   int result;
57078
57079   {
57080     try {
57081       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
57082     } catch (std::out_of_range& e) {
57083       {
57084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57085       };
57086     } catch (std::exception& e) {
57087       {
57088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57089       };
57090     } catch (Dali::DaliException e) {
57091       {
57092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57093       };
57094     } catch (...) {
57095       {
57096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57097       };
57098     }
57099   }
57100
57101   jresult = (int)result;
57102   return jresult;
57103 }
57104
57105
57106 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
57107   int jresult ;
57108   int result;
57109
57110   {
57111     try {
57112       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
57113     } catch (std::out_of_range& e) {
57114       {
57115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57116       };
57117     } catch (std::exception& e) {
57118       {
57119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57120       };
57121     } catch (Dali::DaliException e) {
57122       {
57123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57124       };
57125     } catch (...) {
57126       {
57127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57128       };
57129     }
57130   }
57131
57132   jresult = (int)result;
57133   return jresult;
57134 }
57135
57136
57137 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
57138   int jresult ;
57139   int result;
57140
57141   {
57142     try {
57143       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
57144     } catch (std::out_of_range& e) {
57145       {
57146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57147       };
57148     } catch (std::exception& e) {
57149       {
57150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57151       };
57152     } catch (Dali::DaliException e) {
57153       {
57154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57155       };
57156     } catch (...) {
57157       {
57158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57159       };
57160     }
57161   }
57162
57163   jresult = (int)result;
57164   return jresult;
57165 }
57166
57167
57168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57169   int jresult ;
57170   int result;
57171
57172   {
57173     try {
57174       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57175     } catch (std::out_of_range& e) {
57176       {
57177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57178       };
57179     } catch (std::exception& e) {
57180       {
57181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57182       };
57183     } catch (Dali::DaliException e) {
57184       {
57185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57186       };
57187     } catch (...) {
57188       {
57189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57190       };
57191     }
57192   }
57193
57194   jresult = (int)result;
57195   return jresult;
57196 }
57197
57198
57199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57200   int jresult ;
57201   int result;
57202
57203   {
57204     try {
57205       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57206     } catch (std::out_of_range& e) {
57207       {
57208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57209       };
57210     } catch (std::exception& e) {
57211       {
57212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57213       };
57214     } catch (Dali::DaliException e) {
57215       {
57216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57217       };
57218     } catch (...) {
57219       {
57220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57221       };
57222     }
57223   }
57224
57225   jresult = (int)result;
57226   return jresult;
57227 }
57228
57229
57230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57231   int jresult ;
57232   int result;
57233
57234   {
57235     try {
57236       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57237     } catch (std::out_of_range& e) {
57238       {
57239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57240       };
57241     } catch (std::exception& e) {
57242       {
57243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57244       };
57245     } catch (Dali::DaliException e) {
57246       {
57247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57248       };
57249     } catch (...) {
57250       {
57251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57252       };
57253     }
57254   }
57255
57256   jresult = (int)result;
57257   return jresult;
57258 }
57259
57260
57261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57262   int jresult ;
57263   int result;
57264
57265   {
57266     try {
57267       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57268     } catch (std::out_of_range& e) {
57269       {
57270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57271       };
57272     } catch (std::exception& e) {
57273       {
57274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57275       };
57276     } catch (Dali::DaliException e) {
57277       {
57278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57279       };
57280     } catch (...) {
57281       {
57282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57283       };
57284     }
57285   }
57286
57287   jresult = (int)result;
57288   return jresult;
57289 }
57290
57291
57292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57293   int jresult ;
57294   int result;
57295
57296   {
57297     try {
57298       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57299     } catch (std::out_of_range& e) {
57300       {
57301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57302       };
57303     } catch (std::exception& e) {
57304       {
57305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57306       };
57307     } catch (Dali::DaliException e) {
57308       {
57309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57310       };
57311     } catch (...) {
57312       {
57313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57314       };
57315     }
57316   }
57317
57318   jresult = (int)result;
57319   return jresult;
57320 }
57321
57322
57323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57324   void * jresult ;
57325   Dali::Toolkit::Builder *result = 0 ;
57326
57327   {
57328     try {
57329       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57330     } catch (std::out_of_range& e) {
57331       {
57332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57333       };
57334     } catch (std::exception& e) {
57335       {
57336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57337       };
57338     } catch (Dali::DaliException e) {
57339       {
57340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57341       };
57342     } catch (...) {
57343       {
57344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57345       };
57346     }
57347   }
57348
57349   jresult = (void *)result;
57350   return jresult;
57351 }
57352
57353
57354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57355   void * jresult ;
57356   Dali::Toolkit::Builder result;
57357
57358   {
57359     try {
57360       result = Dali::Toolkit::Builder::New();
57361     } catch (std::out_of_range& e) {
57362       {
57363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57364       };
57365     } catch (std::exception& e) {
57366       {
57367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57368       };
57369     } catch (Dali::DaliException e) {
57370       {
57371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57372       };
57373     } catch (...) {
57374       {
57375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57376       };
57377     }
57378   }
57379
57380   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57381   return jresult;
57382 }
57383
57384
57385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57386   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57387
57388   arg1 = (Dali::Toolkit::Builder *)jarg1;
57389   {
57390     try {
57391       delete arg1;
57392     } catch (std::out_of_range& e) {
57393       {
57394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57395       };
57396     } catch (std::exception& e) {
57397       {
57398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57399       };
57400     } catch (Dali::DaliException e) {
57401       {
57402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57403       };
57404     } catch (...) {
57405       {
57406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57407       };
57408     }
57409   }
57410
57411 }
57412
57413
57414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57415   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57416   std::string *arg2 = 0 ;
57417   Dali::Toolkit::Builder::UIFormat arg3 ;
57418
57419   arg1 = (Dali::Toolkit::Builder *)jarg1;
57420   if (!jarg2) {
57421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57422     return ;
57423   }
57424   std::string arg2_str(jarg2);
57425   arg2 = &arg2_str;
57426   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57427   {
57428     try {
57429       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57430     } catch (std::out_of_range& e) {
57431       {
57432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57433       };
57434     } catch (std::exception& e) {
57435       {
57436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57437       };
57438     } catch (Dali::DaliException e) {
57439       {
57440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57441       };
57442     } catch (...) {
57443       {
57444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57445       };
57446     }
57447   }
57448
57449
57450   //argout typemap for const std::string&
57451
57452 }
57453
57454
57455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57456   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57457   std::string *arg2 = 0 ;
57458
57459   arg1 = (Dali::Toolkit::Builder *)jarg1;
57460   if (!jarg2) {
57461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57462     return ;
57463   }
57464   std::string arg2_str(jarg2);
57465   arg2 = &arg2_str;
57466   {
57467     try {
57468       (arg1)->LoadFromString((std::string const &)*arg2);
57469     } catch (std::out_of_range& e) {
57470       {
57471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57472       };
57473     } catch (std::exception& e) {
57474       {
57475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57476       };
57477     } catch (Dali::DaliException e) {
57478       {
57479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57480       };
57481     } catch (...) {
57482       {
57483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57484       };
57485     }
57486   }
57487
57488
57489   //argout typemap for const std::string&
57490
57491 }
57492
57493
57494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57495   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57496   Dali::Property::Map *arg2 = 0 ;
57497
57498   arg1 = (Dali::Toolkit::Builder *)jarg1;
57499   arg2 = (Dali::Property::Map *)jarg2;
57500   if (!arg2) {
57501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57502     return ;
57503   }
57504   {
57505     try {
57506       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57507     } catch (std::out_of_range& e) {
57508       {
57509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57510       };
57511     } catch (std::exception& e) {
57512       {
57513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57514       };
57515     } catch (Dali::DaliException e) {
57516       {
57517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57518       };
57519     } catch (...) {
57520       {
57521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57522       };
57523     }
57524   }
57525
57526 }
57527
57528
57529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57530   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57531   std::string *arg2 = 0 ;
57532   Dali::Property::Value *arg3 = 0 ;
57533
57534   arg1 = (Dali::Toolkit::Builder *)jarg1;
57535   if (!jarg2) {
57536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57537     return ;
57538   }
57539   std::string arg2_str(jarg2);
57540   arg2 = &arg2_str;
57541   arg3 = (Dali::Property::Value *)jarg3;
57542   if (!arg3) {
57543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57544     return ;
57545   }
57546   {
57547     try {
57548       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57549     } catch (std::out_of_range& e) {
57550       {
57551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57552       };
57553     } catch (std::exception& e) {
57554       {
57555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57556       };
57557     } catch (Dali::DaliException e) {
57558       {
57559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57560       };
57561     } catch (...) {
57562       {
57563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57564       };
57565     }
57566   }
57567
57568
57569   //argout typemap for const std::string&
57570
57571 }
57572
57573
57574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57575   void * jresult ;
57576   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57577   Dali::Property::Map *result = 0 ;
57578
57579   arg1 = (Dali::Toolkit::Builder *)jarg1;
57580   {
57581     try {
57582       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57583     } catch (std::out_of_range& e) {
57584       {
57585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57586       };
57587     } catch (std::exception& e) {
57588       {
57589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57590       };
57591     } catch (Dali::DaliException e) {
57592       {
57593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57594       };
57595     } catch (...) {
57596       {
57597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57598       };
57599     }
57600   }
57601
57602   jresult = (void *)result;
57603   return jresult;
57604 }
57605
57606
57607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57608   void * jresult ;
57609   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57610   std::string *arg2 = 0 ;
57611   Dali::Property::Value *result = 0 ;
57612
57613   arg1 = (Dali::Toolkit::Builder *)jarg1;
57614   if (!jarg2) {
57615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57616     return 0;
57617   }
57618   std::string arg2_str(jarg2);
57619   arg2 = &arg2_str;
57620   {
57621     try {
57622       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57623     } catch (std::out_of_range& e) {
57624       {
57625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57626       };
57627     } catch (std::exception& e) {
57628       {
57629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57630       };
57631     } catch (Dali::DaliException e) {
57632       {
57633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57634       };
57635     } catch (...) {
57636       {
57637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57638       };
57639     }
57640   }
57641
57642   jresult = (void *)result;
57643
57644   //argout typemap for const std::string&
57645
57646   return jresult;
57647 }
57648
57649
57650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57651   void * jresult ;
57652   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57653   std::string *arg2 = 0 ;
57654   Dali::Animation result;
57655
57656   arg1 = (Dali::Toolkit::Builder *)jarg1;
57657   if (!jarg2) {
57658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57659     return 0;
57660   }
57661   std::string arg2_str(jarg2);
57662   arg2 = &arg2_str;
57663   {
57664     try {
57665       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57666     } catch (std::out_of_range& e) {
57667       {
57668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57669       };
57670     } catch (std::exception& e) {
57671       {
57672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57673       };
57674     } catch (Dali::DaliException e) {
57675       {
57676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57677       };
57678     } catch (...) {
57679       {
57680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57681       };
57682     }
57683   }
57684
57685   jresult = new Dali::Animation((const Dali::Animation &)result);
57686
57687   //argout typemap for const std::string&
57688
57689   return jresult;
57690 }
57691
57692
57693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57694   void * jresult ;
57695   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57696   std::string *arg2 = 0 ;
57697   Dali::Property::Map *arg3 = 0 ;
57698   Dali::Animation result;
57699
57700   arg1 = (Dali::Toolkit::Builder *)jarg1;
57701   if (!jarg2) {
57702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57703     return 0;
57704   }
57705   std::string arg2_str(jarg2);
57706   arg2 = &arg2_str;
57707   arg3 = (Dali::Property::Map *)jarg3;
57708   if (!arg3) {
57709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57710     return 0;
57711   }
57712   {
57713     try {
57714       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57715     } catch (std::out_of_range& e) {
57716       {
57717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57718       };
57719     } catch (std::exception& e) {
57720       {
57721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57722       };
57723     } catch (Dali::DaliException e) {
57724       {
57725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57726       };
57727     } catch (...) {
57728       {
57729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57730       };
57731     }
57732   }
57733
57734   jresult = new Dali::Animation((const Dali::Animation &)result);
57735
57736   //argout typemap for const std::string&
57737
57738   return jresult;
57739 }
57740
57741
57742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57743   void * jresult ;
57744   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57745   std::string *arg2 = 0 ;
57746   Dali::Actor arg3 ;
57747   Dali::Actor *argp3 ;
57748   Dali::Animation result;
57749
57750   arg1 = (Dali::Toolkit::Builder *)jarg1;
57751   if (!jarg2) {
57752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57753     return 0;
57754   }
57755   std::string arg2_str(jarg2);
57756   arg2 = &arg2_str;
57757   argp3 = (Dali::Actor *)jarg3;
57758   if (!argp3) {
57759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57760     return 0;
57761   }
57762   arg3 = *argp3;
57763   {
57764     try {
57765       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57766     } catch (std::out_of_range& e) {
57767       {
57768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57769       };
57770     } catch (std::exception& e) {
57771       {
57772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57773       };
57774     } catch (Dali::DaliException e) {
57775       {
57776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57777       };
57778     } catch (...) {
57779       {
57780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57781       };
57782     }
57783   }
57784
57785   jresult = new Dali::Animation((const Dali::Animation &)result);
57786
57787   //argout typemap for const std::string&
57788
57789   return jresult;
57790 }
57791
57792
57793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57794   void * jresult ;
57795   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57796   std::string *arg2 = 0 ;
57797   Dali::Property::Map *arg3 = 0 ;
57798   Dali::Actor arg4 ;
57799   Dali::Actor *argp4 ;
57800   Dali::Animation result;
57801
57802   arg1 = (Dali::Toolkit::Builder *)jarg1;
57803   if (!jarg2) {
57804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57805     return 0;
57806   }
57807   std::string arg2_str(jarg2);
57808   arg2 = &arg2_str;
57809   arg3 = (Dali::Property::Map *)jarg3;
57810   if (!arg3) {
57811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57812     return 0;
57813   }
57814   argp4 = (Dali::Actor *)jarg4;
57815   if (!argp4) {
57816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57817     return 0;
57818   }
57819   arg4 = *argp4;
57820   {
57821     try {
57822       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57823     } catch (std::out_of_range& e) {
57824       {
57825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57826       };
57827     } catch (std::exception& e) {
57828       {
57829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57830       };
57831     } catch (Dali::DaliException e) {
57832       {
57833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57834       };
57835     } catch (...) {
57836       {
57837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57838       };
57839     }
57840   }
57841
57842   jresult = new Dali::Animation((const Dali::Animation &)result);
57843
57844   //argout typemap for const std::string&
57845
57846   return jresult;
57847 }
57848
57849
57850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
57851   void * jresult ;
57852   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57853   std::string *arg2 = 0 ;
57854   Dali::BaseHandle result;
57855
57856   arg1 = (Dali::Toolkit::Builder *)jarg1;
57857   if (!jarg2) {
57858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57859     return 0;
57860   }
57861   std::string arg2_str(jarg2);
57862   arg2 = &arg2_str;
57863   {
57864     try {
57865       result = (arg1)->Create((std::string const &)*arg2);
57866     } catch (std::out_of_range& e) {
57867       {
57868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57869       };
57870     } catch (std::exception& e) {
57871       {
57872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57873       };
57874     } catch (Dali::DaliException e) {
57875       {
57876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57877       };
57878     } catch (...) {
57879       {
57880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57881       };
57882     }
57883   }
57884
57885   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57886
57887   //argout typemap for const std::string&
57888
57889   return jresult;
57890 }
57891
57892
57893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57894   void * jresult ;
57895   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57896   std::string *arg2 = 0 ;
57897   Dali::Property::Map *arg3 = 0 ;
57898   Dali::BaseHandle result;
57899
57900   arg1 = (Dali::Toolkit::Builder *)jarg1;
57901   if (!jarg2) {
57902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57903     return 0;
57904   }
57905   std::string arg2_str(jarg2);
57906   arg2 = &arg2_str;
57907   arg3 = (Dali::Property::Map *)jarg3;
57908   if (!arg3) {
57909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57910     return 0;
57911   }
57912   {
57913     try {
57914       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57915     } catch (std::out_of_range& e) {
57916       {
57917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57918       };
57919     } catch (std::exception& e) {
57920       {
57921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57922       };
57923     } catch (Dali::DaliException e) {
57924       {
57925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57926       };
57927     } catch (...) {
57928       {
57929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57930       };
57931     }
57932   }
57933
57934   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57935
57936   //argout typemap for const std::string&
57937
57938   return jresult;
57939 }
57940
57941
57942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
57943   void * jresult ;
57944   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57945   std::string *arg2 = 0 ;
57946   Dali::BaseHandle result;
57947
57948   arg1 = (Dali::Toolkit::Builder *)jarg1;
57949   if (!jarg2) {
57950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57951     return 0;
57952   }
57953   std::string arg2_str(jarg2);
57954   arg2 = &arg2_str;
57955   {
57956     try {
57957       result = (arg1)->CreateFromJson((std::string const &)*arg2);
57958     } catch (std::out_of_range& e) {
57959       {
57960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57961       };
57962     } catch (std::exception& e) {
57963       {
57964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57965       };
57966     } catch (Dali::DaliException e) {
57967       {
57968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57969       };
57970     } catch (...) {
57971       {
57972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57973       };
57974     }
57975   }
57976
57977   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57978
57979   //argout typemap for const std::string&
57980
57981   return jresult;
57982 }
57983
57984
57985 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
57986   unsigned int jresult ;
57987   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57988   std::string *arg2 = 0 ;
57989   Dali::Handle *arg3 = 0 ;
57990   bool result;
57991
57992   arg1 = (Dali::Toolkit::Builder *)jarg1;
57993   if (!jarg2) {
57994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57995     return 0;
57996   }
57997   std::string arg2_str(jarg2);
57998   arg2 = &arg2_str;
57999   arg3 = (Dali::Handle *)jarg3;
58000   if (!arg3) {
58001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58002     return 0;
58003   }
58004   {
58005     try {
58006       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58007     } catch (std::out_of_range& e) {
58008       {
58009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58010       };
58011     } catch (std::exception& e) {
58012       {
58013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58014       };
58015     } catch (Dali::DaliException e) {
58016       {
58017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58018       };
58019     } catch (...) {
58020       {
58021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58022       };
58023     }
58024   }
58025
58026   jresult = result;
58027
58028   //argout typemap for const std::string&
58029
58030   return jresult;
58031 }
58032
58033
58034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
58035   unsigned int jresult ;
58036   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58037   Dali::Handle *arg2 = 0 ;
58038   std::string *arg3 = 0 ;
58039   bool result;
58040
58041   arg1 = (Dali::Toolkit::Builder *)jarg1;
58042   arg2 = (Dali::Handle *)jarg2;
58043   if (!arg2) {
58044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58045     return 0;
58046   }
58047   if (!jarg3) {
58048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58049     return 0;
58050   }
58051   std::string arg3_str(jarg3);
58052   arg3 = &arg3_str;
58053   {
58054     try {
58055       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
58056     } catch (std::out_of_range& e) {
58057       {
58058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58059       };
58060     } catch (std::exception& e) {
58061       {
58062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58063       };
58064     } catch (Dali::DaliException e) {
58065       {
58066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58067       };
58068     } catch (...) {
58069       {
58070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58071       };
58072     }
58073   }
58074
58075   jresult = result;
58076
58077   //argout typemap for const std::string&
58078
58079   return jresult;
58080 }
58081
58082
58083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
58084   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58085   Dali::Actor arg2 ;
58086   Dali::Actor *argp2 ;
58087
58088   arg1 = (Dali::Toolkit::Builder *)jarg1;
58089   argp2 = (Dali::Actor *)jarg2;
58090   if (!argp2) {
58091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58092     return ;
58093   }
58094   arg2 = *argp2;
58095   {
58096     try {
58097       (arg1)->AddActors(arg2);
58098     } catch (std::out_of_range& e) {
58099       {
58100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58101       };
58102     } catch (std::exception& e) {
58103       {
58104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58105       };
58106     } catch (Dali::DaliException e) {
58107       {
58108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58109       };
58110     } catch (...) {
58111       {
58112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58113       };
58114     }
58115   }
58116
58117 }
58118
58119
58120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58121   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58122   std::string *arg2 = 0 ;
58123   Dali::Actor arg3 ;
58124   Dali::Actor *argp3 ;
58125
58126   arg1 = (Dali::Toolkit::Builder *)jarg1;
58127   if (!jarg2) {
58128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58129     return ;
58130   }
58131   std::string arg2_str(jarg2);
58132   arg2 = &arg2_str;
58133   argp3 = (Dali::Actor *)jarg3;
58134   if (!argp3) {
58135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58136     return ;
58137   }
58138   arg3 = *argp3;
58139   {
58140     try {
58141       (arg1)->AddActors((std::string const &)*arg2,arg3);
58142     } catch (std::out_of_range& e) {
58143       {
58144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58145       };
58146     } catch (std::exception& e) {
58147       {
58148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58149       };
58150     } catch (Dali::DaliException e) {
58151       {
58152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58153       };
58154     } catch (...) {
58155       {
58156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58157       };
58158     }
58159   }
58160
58161
58162   //argout typemap for const std::string&
58163
58164 }
58165
58166
58167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
58168   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58169   std::string *arg2 = 0 ;
58170
58171   arg1 = (Dali::Toolkit::Builder *)jarg1;
58172   if (!jarg2) {
58173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58174     return ;
58175   }
58176   std::string arg2_str(jarg2);
58177   arg2 = &arg2_str;
58178   {
58179     try {
58180       (arg1)->CreateRenderTask((std::string const &)*arg2);
58181     } catch (std::out_of_range& e) {
58182       {
58183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58184       };
58185     } catch (std::exception& e) {
58186       {
58187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58188       };
58189     } catch (Dali::DaliException e) {
58190       {
58191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58192       };
58193     } catch (...) {
58194       {
58195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58196       };
58197     }
58198   }
58199
58200
58201   //argout typemap for const std::string&
58202
58203 }
58204
58205
58206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58207   void * jresult ;
58208   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58209   std::string *arg2 = 0 ;
58210   Dali::Path result;
58211
58212   arg1 = (Dali::Toolkit::Builder *)jarg1;
58213   if (!jarg2) {
58214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58215     return 0;
58216   }
58217   std::string arg2_str(jarg2);
58218   arg2 = &arg2_str;
58219   {
58220     try {
58221       result = (arg1)->GetPath((std::string const &)*arg2);
58222     } catch (std::out_of_range& e) {
58223       {
58224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58225       };
58226     } catch (std::exception& e) {
58227       {
58228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58229       };
58230     } catch (Dali::DaliException e) {
58231       {
58232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58233       };
58234     } catch (...) {
58235       {
58236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58237       };
58238     }
58239   }
58240
58241   jresult = new Dali::Path((const Dali::Path &)result);
58242
58243   //argout typemap for const std::string&
58244
58245   return jresult;
58246 }
58247
58248
58249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58250   void * jresult ;
58251   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58252   std::string *arg2 = 0 ;
58253   Dali::PathConstrainer result;
58254
58255   arg1 = (Dali::Toolkit::Builder *)jarg1;
58256   if (!jarg2) {
58257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58258     return 0;
58259   }
58260   std::string arg2_str(jarg2);
58261   arg2 = &arg2_str;
58262   {
58263     try {
58264       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58265     } catch (std::out_of_range& e) {
58266       {
58267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58268       };
58269     } catch (std::exception& e) {
58270       {
58271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58272       };
58273     } catch (Dali::DaliException e) {
58274       {
58275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58276       };
58277     } catch (...) {
58278       {
58279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58280       };
58281     }
58282   }
58283
58284   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58285
58286   //argout typemap for const std::string&
58287
58288   return jresult;
58289 }
58290
58291
58292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58293   void * jresult ;
58294   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58295   std::string *arg2 = 0 ;
58296   Dali::LinearConstrainer result;
58297
58298   arg1 = (Dali::Toolkit::Builder *)jarg1;
58299   if (!jarg2) {
58300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58301     return 0;
58302   }
58303   std::string arg2_str(jarg2);
58304   arg2 = &arg2_str;
58305   {
58306     try {
58307       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58308     } catch (std::out_of_range& e) {
58309       {
58310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58311       };
58312     } catch (std::exception& e) {
58313       {
58314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58315       };
58316     } catch (Dali::DaliException e) {
58317       {
58318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58319       };
58320     } catch (...) {
58321       {
58322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58323       };
58324     }
58325   }
58326
58327   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58328
58329   //argout typemap for const std::string&
58330
58331   return jresult;
58332 }
58333
58334
58335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58336   void * jresult ;
58337   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58338   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58339
58340   arg1 = (Dali::Toolkit::Builder *)jarg1;
58341   {
58342     try {
58343       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
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 = (void *)result;
58364   return jresult;
58365 }
58366
58367
58368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58369   void * jresult ;
58370   Dali::Toolkit::TransitionData *result = 0 ;
58371
58372   {
58373     try {
58374       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58375     } catch (std::out_of_range& e) {
58376       {
58377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58378       };
58379     } catch (std::exception& e) {
58380       {
58381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58382       };
58383     } catch (Dali::DaliException e) {
58384       {
58385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58386       };
58387     } catch (...) {
58388       {
58389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58390       };
58391     }
58392   }
58393
58394   jresult = (void *)result;
58395   return jresult;
58396 }
58397
58398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58399   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58400
58401   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58402   {
58403     try {
58404       delete arg1;
58405     } catch (std::out_of_range& e) {
58406       {
58407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58408       };
58409     } catch (std::exception& e) {
58410       {
58411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58412       };
58413     } catch (Dali::DaliException e) {
58414       {
58415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58416       };
58417     } catch (...) {
58418       {
58419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58420       };
58421     }
58422   }
58423
58424 }
58425
58426
58427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58428   void * jresult ;
58429   Dali::Property::Map *arg1 = 0 ;
58430   Dali::Toolkit::TransitionData result;
58431
58432   arg1 = (Dali::Property::Map *)jarg1;
58433   if (!arg1) {
58434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58435     return 0;
58436   }
58437   {
58438     try {
58439       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58440     } catch (std::out_of_range& e) {
58441       {
58442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58443       };
58444     } catch (std::exception& e) {
58445       {
58446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58447       };
58448     } catch (Dali::DaliException e) {
58449       {
58450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58451       };
58452     } catch (...) {
58453       {
58454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58455       };
58456     }
58457   }
58458
58459   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58460   return jresult;
58461 }
58462
58463
58464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58465   void * jresult ;
58466   Dali::Property::Array *arg1 = 0 ;
58467   Dali::Toolkit::TransitionData result;
58468
58469   arg1 = (Dali::Property::Array *)jarg1;
58470   if (!arg1) {
58471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58472     return 0;
58473   }
58474   {
58475     try {
58476       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58477     } catch (std::out_of_range& e) {
58478       {
58479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58480       };
58481     } catch (std::exception& e) {
58482       {
58483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58484       };
58485     } catch (Dali::DaliException e) {
58486       {
58487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58488       };
58489     } catch (...) {
58490       {
58491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58492       };
58493     }
58494   }
58495
58496   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58497   return jresult;
58498 }
58499
58500
58501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58502   void * jresult ;
58503   Dali::BaseHandle arg1 ;
58504   Dali::BaseHandle *argp1 ;
58505   Dali::Toolkit::TransitionData result;
58506
58507   argp1 = (Dali::BaseHandle *)jarg1;
58508   if (!argp1) {
58509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58510     return 0;
58511   }
58512   arg1 = *argp1;
58513   {
58514     try {
58515       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58516     } catch (std::out_of_range& e) {
58517       {
58518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58519       };
58520     } catch (std::exception& e) {
58521       {
58522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58523       };
58524     } catch (Dali::DaliException e) {
58525       {
58526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58527       };
58528     } catch (...) {
58529       {
58530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58531       };
58532     }
58533   }
58534
58535   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58536   return jresult;
58537 }
58538
58539
58540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58541   void * jresult ;
58542   Dali::Toolkit::TransitionData *arg1 = 0 ;
58543   Dali::Toolkit::TransitionData *result = 0 ;
58544
58545   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58546   if (!arg1) {
58547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58548     return 0;
58549   }
58550   {
58551     try {
58552       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58553     } catch (std::out_of_range& e) {
58554       {
58555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58556       };
58557     } catch (std::exception& e) {
58558       {
58559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58560       };
58561     } catch (Dali::DaliException e) {
58562       {
58563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58564       };
58565     } catch (...) {
58566       {
58567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58568       };
58569     }
58570   }
58571
58572   jresult = (void *)result;
58573   return jresult;
58574 }
58575
58576
58577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58578   void * jresult ;
58579   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58580   Dali::Toolkit::TransitionData *arg2 = 0 ;
58581   Dali::Toolkit::TransitionData *result = 0 ;
58582
58583   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58584   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58585   if (!arg2) {
58586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58587     return 0;
58588   }
58589   {
58590     try {
58591       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58592     } catch (std::out_of_range& e) {
58593       {
58594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58595       };
58596     } catch (std::exception& e) {
58597       {
58598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58599       };
58600     } catch (Dali::DaliException e) {
58601       {
58602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58603       };
58604     } catch (...) {
58605       {
58606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58607       };
58608     }
58609   }
58610
58611   jresult = (void *)result;
58612   return jresult;
58613 }
58614
58615
58616 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58617   unsigned long jresult ;
58618   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58619   size_t result;
58620
58621   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58622   {
58623     try {
58624       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58625     } catch (std::out_of_range& e) {
58626       {
58627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58628       };
58629     } catch (std::exception& e) {
58630       {
58631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58632       };
58633     } catch (Dali::DaliException e) {
58634       {
58635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58636       };
58637     } catch (...) {
58638       {
58639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58640       };
58641     }
58642   }
58643
58644   jresult = (unsigned long)result;
58645   return jresult;
58646 }
58647
58648
58649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58650   void * jresult ;
58651   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58652   size_t arg2 ;
58653   Dali::Property::Map result;
58654
58655   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58656   arg2 = (size_t)jarg2;
58657   {
58658     try {
58659       result = (arg1)->GetAnimatorAt(arg2);
58660     } catch (std::out_of_range& e) {
58661       {
58662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58663       };
58664     } catch (std::exception& e) {
58665       {
58666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58667       };
58668     } catch (Dali::DaliException e) {
58669       {
58670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58671       };
58672     } catch (...) {
58673       {
58674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58675       };
58676     }
58677   }
58678
58679   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58680   return jresult;
58681 }
58682
58683
58684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58685   int jresult ;
58686   int result;
58687
58688   {
58689     try {
58690       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58691     } catch (std::out_of_range& e) {
58692       {
58693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58694       };
58695     } catch (std::exception& e) {
58696       {
58697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58698       };
58699     } catch (Dali::DaliException e) {
58700       {
58701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58702       };
58703     } catch (...) {
58704       {
58705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58706       };
58707     }
58708   }
58709
58710   jresult = (int)result;
58711   return jresult;
58712 }
58713
58714
58715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58716   int jresult ;
58717   int result;
58718
58719   {
58720     try {
58721       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58722     } catch (std::out_of_range& e) {
58723       {
58724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58725       };
58726     } catch (std::exception& e) {
58727       {
58728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58729       };
58730     } catch (Dali::DaliException e) {
58731       {
58732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58733       };
58734     } catch (...) {
58735       {
58736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58737       };
58738     }
58739   }
58740
58741   jresult = (int)result;
58742   return jresult;
58743 }
58744
58745
58746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58747   int jresult ;
58748   int result;
58749
58750   {
58751     try {
58752       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58753     } catch (std::out_of_range& e) {
58754       {
58755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58756       };
58757     } catch (std::exception& e) {
58758       {
58759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58760       };
58761     } catch (Dali::DaliException e) {
58762       {
58763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58764       };
58765     } catch (...) {
58766       {
58767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58768       };
58769     }
58770   }
58771
58772   jresult = (int)result;
58773   return jresult;
58774 }
58775
58776
58777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58778   int jresult ;
58779   int result;
58780
58781   {
58782     try {
58783       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58784     } catch (std::out_of_range& e) {
58785       {
58786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58787       };
58788     } catch (std::exception& e) {
58789       {
58790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58791       };
58792     } catch (Dali::DaliException e) {
58793       {
58794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58795       };
58796     } catch (...) {
58797       {
58798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58799       };
58800     }
58801   }
58802
58803   jresult = (int)result;
58804   return jresult;
58805 }
58806
58807
58808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58809   int jresult ;
58810   int result;
58811
58812   {
58813     try {
58814       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58815     } catch (std::out_of_range& e) {
58816       {
58817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58818       };
58819     } catch (std::exception& e) {
58820       {
58821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58822       };
58823     } catch (Dali::DaliException e) {
58824       {
58825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58826       };
58827     } catch (...) {
58828       {
58829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58830       };
58831     }
58832   }
58833
58834   jresult = (int)result;
58835   return jresult;
58836 }
58837
58838
58839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58840   int jresult ;
58841   int result;
58842
58843   {
58844     try {
58845       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
58846     } catch (std::out_of_range& e) {
58847       {
58848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58849       };
58850     } catch (std::exception& e) {
58851       {
58852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58853       };
58854     } catch (Dali::DaliException e) {
58855       {
58856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58857       };
58858     } catch (...) {
58859       {
58860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58861       };
58862     }
58863   }
58864
58865   jresult = (int)result;
58866   return jresult;
58867 }
58868
58869
58870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
58871   int jresult ;
58872   int result;
58873
58874   {
58875     try {
58876       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
58877     } catch (std::out_of_range& e) {
58878       {
58879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58880       };
58881     } catch (std::exception& e) {
58882       {
58883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58884       };
58885     } catch (Dali::DaliException e) {
58886       {
58887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58888       };
58889     } catch (...) {
58890       {
58891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58892       };
58893     }
58894   }
58895
58896   jresult = (int)result;
58897   return jresult;
58898 }
58899
58900
58901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
58902   int jresult ;
58903   int result;
58904
58905   {
58906     try {
58907       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
58908     } catch (std::out_of_range& e) {
58909       {
58910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58911       };
58912     } catch (std::exception& e) {
58913       {
58914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58915       };
58916     } catch (Dali::DaliException e) {
58917       {
58918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58919       };
58920     } catch (...) {
58921       {
58922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58923       };
58924     }
58925   }
58926
58927   jresult = (int)result;
58928   return jresult;
58929 }
58930
58931
58932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
58933   int jresult ;
58934   int result;
58935
58936   {
58937     try {
58938       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
58939     } catch (std::out_of_range& e) {
58940       {
58941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58942       };
58943     } catch (std::exception& e) {
58944       {
58945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58946       };
58947     } catch (Dali::DaliException e) {
58948       {
58949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58950       };
58951     } catch (...) {
58952       {
58953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58954       };
58955     }
58956   }
58957
58958   jresult = (int)result;
58959   return jresult;
58960 }
58961
58962
58963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
58964   int jresult ;
58965   int result;
58966
58967   {
58968     try {
58969       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
58970     } catch (std::out_of_range& e) {
58971       {
58972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58973       };
58974     } catch (std::exception& e) {
58975       {
58976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58977       };
58978     } catch (Dali::DaliException e) {
58979       {
58980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58981       };
58982     } catch (...) {
58983       {
58984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58985       };
58986     }
58987   }
58988
58989   jresult = (int)result;
58990   return jresult;
58991 }
58992
58993
58994 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
58995   int jresult ;
58996   int result;
58997
58998   {
58999     try {
59000       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
59001     } catch (std::out_of_range& e) {
59002       {
59003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59004       };
59005     } catch (std::exception& e) {
59006       {
59007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59008       };
59009     } catch (Dali::DaliException e) {
59010       {
59011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59012       };
59013     } catch (...) {
59014       {
59015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59016       };
59017     }
59018   }
59019
59020   jresult = (int)result;
59021   return jresult;
59022 }
59023
59024
59025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59026   int jresult ;
59027   int result;
59028
59029   {
59030     try {
59031       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59032     } catch (std::out_of_range& e) {
59033       {
59034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59035       };
59036     } catch (std::exception& e) {
59037       {
59038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59039       };
59040     } catch (Dali::DaliException e) {
59041       {
59042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59043       };
59044     } catch (...) {
59045       {
59046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59047       };
59048     }
59049   }
59050
59051   jresult = (int)result;
59052   return jresult;
59053 }
59054
59055
59056 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59057   int jresult ;
59058   int result;
59059
59060   {
59061     try {
59062       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59063     } catch (std::out_of_range& e) {
59064       {
59065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59066       };
59067     } catch (std::exception& e) {
59068       {
59069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59070       };
59071     } catch (Dali::DaliException e) {
59072       {
59073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59074       };
59075     } catch (...) {
59076       {
59077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59078       };
59079     }
59080   }
59081
59082   jresult = (int)result;
59083   return jresult;
59084 }
59085
59086
59087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
59088   int jresult ;
59089   int result;
59090
59091   {
59092     try {
59093       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
59094     } catch (std::out_of_range& e) {
59095       {
59096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59097       };
59098     } catch (std::exception& e) {
59099       {
59100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59101       };
59102     } catch (Dali::DaliException e) {
59103       {
59104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59105       };
59106     } catch (...) {
59107       {
59108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59109       };
59110     }
59111   }
59112
59113   jresult = (int)result;
59114   return jresult;
59115 }
59116
59117
59118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59119   void * jresult ;
59120   Dali::Toolkit::Control result;
59121
59122   {
59123     try {
59124       result = Dali::Toolkit::Internal::Control::New();
59125     } catch (std::out_of_range& e) {
59126       {
59127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59128       };
59129     } catch (std::exception& e) {
59130       {
59131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59132       };
59133     } catch (Dali::DaliException e) {
59134       {
59135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59136       };
59137     } catch (...) {
59138       {
59139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59140       };
59141     }
59142   }
59143
59144   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59145   return jresult;
59146 }
59147
59148
59149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59150   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59151   std::string *arg2 = 0 ;
59152
59153   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59154   if (!jarg2) {
59155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59156     return ;
59157   }
59158   std::string arg2_str(jarg2);
59159   arg2 = &arg2_str;
59160   {
59161     try {
59162       (arg1)->SetStyleName((std::string const &)*arg2);
59163     } catch (std::out_of_range& e) {
59164       {
59165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59166       };
59167     } catch (std::exception& e) {
59168       {
59169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59170       };
59171     } catch (Dali::DaliException e) {
59172       {
59173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59174       };
59175     } catch (...) {
59176       {
59177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59178       };
59179     }
59180   }
59181
59182
59183   //argout typemap for const std::string&
59184
59185 }
59186
59187
59188 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59189   char * jresult ;
59190   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59191   std::string *result = 0 ;
59192
59193   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59194   {
59195     try {
59196       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59197     } catch (std::out_of_range& e) {
59198       {
59199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59200       };
59201     } catch (std::exception& e) {
59202       {
59203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59204       };
59205     } catch (Dali::DaliException e) {
59206       {
59207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59208       };
59209     } catch (...) {
59210       {
59211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59212       };
59213     }
59214   }
59215
59216   jresult = SWIG_csharp_string_callback(result->c_str());
59217   return jresult;
59218 }
59219
59220
59221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59222   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59223   Dali::Vector4 *arg2 = 0 ;
59224
59225   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59226   arg2 = (Dali::Vector4 *)jarg2;
59227   if (!arg2) {
59228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59229     return ;
59230   }
59231   {
59232     try {
59233       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59234     } catch (std::out_of_range& e) {
59235       {
59236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59237       };
59238     } catch (std::exception& e) {
59239       {
59240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59241       };
59242     } catch (Dali::DaliException e) {
59243       {
59244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59245       };
59246     } catch (...) {
59247       {
59248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59249       };
59250     }
59251   }
59252
59253 }
59254
59255
59256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
59257   void * jresult ;
59258   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
59259   Dali::Vector4 result;
59260
59261   arg1 = (Dali::Handle *)jarg1;
59262   {
59263     try {
59264       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
59265       if (resultMap)
59266       {
59267         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
59268         if(type && type->Get<int>() == Visual::COLOR )
59269         {
59270           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
59271           if (value)
59272           {
59273             result = value->Get<Vector4>();
59274           }
59275         }
59276       }
59277     } catch (std::out_of_range& e) {
59278       {
59279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59280       };
59281     } catch (std::exception& e) {
59282       {
59283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59284       };
59285     } catch (Dali::DaliException e) {
59286       {
59287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59288       };
59289     } catch (...) {
59290       {
59291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59292       };
59293     }
59294   }
59295
59296   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59297   return jresult;
59298 }
59299
59300
59301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59302   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59303   Dali::Property::Map *arg2 = 0 ;
59304
59305   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59306   arg2 = (Dali::Property::Map *)jarg2;
59307   if (!arg2) {
59308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59309     return ;
59310   }
59311   {
59312     try {
59313       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59314     } catch (std::out_of_range& e) {
59315       {
59316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59317       };
59318     } catch (std::exception& e) {
59319       {
59320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59321       };
59322     } catch (Dali::DaliException e) {
59323       {
59324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59325       };
59326     } catch (...) {
59327       {
59328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59329       };
59330     }
59331   }
59332
59333 }
59334
59335
59336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59337   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59338
59339   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59340   {
59341     try {
59342       (arg1)->ClearBackground();
59343     } catch (std::out_of_range& e) {
59344       {
59345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59346       };
59347     } catch (std::exception& e) {
59348       {
59349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59350       };
59351     } catch (Dali::DaliException e) {
59352       {
59353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59354       };
59355     } catch (...) {
59356       {
59357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59358       };
59359     }
59360   }
59361
59362 }
59363
59364
59365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59366   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59367   Dali::Gesture::Type arg2 ;
59368
59369   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59370   arg2 = (Dali::Gesture::Type)jarg2;
59371   {
59372     try {
59373       (arg1)->EnableGestureDetection(arg2);
59374     } catch (std::out_of_range& e) {
59375       {
59376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59377       };
59378     } catch (std::exception& e) {
59379       {
59380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59381       };
59382     } catch (Dali::DaliException e) {
59383       {
59384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59385       };
59386     } catch (...) {
59387       {
59388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59389       };
59390     }
59391   }
59392
59393 }
59394
59395
59396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59397   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59398   Dali::Gesture::Type arg2 ;
59399
59400   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59401   arg2 = (Dali::Gesture::Type)jarg2;
59402   {
59403     try {
59404       (arg1)->DisableGestureDetection(arg2);
59405     } catch (std::out_of_range& e) {
59406       {
59407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59408       };
59409     } catch (std::exception& e) {
59410       {
59411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59412       };
59413     } catch (Dali::DaliException e) {
59414       {
59415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59416       };
59417     } catch (...) {
59418       {
59419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59420       };
59421     }
59422   }
59423
59424 }
59425
59426
59427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59428   void * jresult ;
59429   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59430   Dali::PinchGestureDetector result;
59431
59432   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59433   {
59434     try {
59435       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59436     } catch (std::out_of_range& e) {
59437       {
59438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59439       };
59440     } catch (std::exception& e) {
59441       {
59442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59443       };
59444     } catch (Dali::DaliException e) {
59445       {
59446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59447       };
59448     } catch (...) {
59449       {
59450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59451       };
59452     }
59453   }
59454
59455   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59456   return jresult;
59457 }
59458
59459
59460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59461   void * jresult ;
59462   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59463   Dali::PanGestureDetector result;
59464
59465   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59466   {
59467     try {
59468       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59469     } catch (std::out_of_range& e) {
59470       {
59471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59472       };
59473     } catch (std::exception& e) {
59474       {
59475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59476       };
59477     } catch (Dali::DaliException e) {
59478       {
59479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59480       };
59481     } catch (...) {
59482       {
59483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59484       };
59485     }
59486   }
59487
59488   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59489   return jresult;
59490 }
59491
59492
59493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59494   void * jresult ;
59495   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59496   Dali::TapGestureDetector result;
59497
59498   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59499   {
59500     try {
59501       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59502     } catch (std::out_of_range& e) {
59503       {
59504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59505       };
59506     } catch (std::exception& e) {
59507       {
59508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59509       };
59510     } catch (Dali::DaliException e) {
59511       {
59512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59513       };
59514     } catch (...) {
59515       {
59516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59517       };
59518     }
59519   }
59520
59521   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59522   return jresult;
59523 }
59524
59525
59526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59527   void * jresult ;
59528   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59529   Dali::LongPressGestureDetector result;
59530
59531   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59532   {
59533     try {
59534       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59535     } catch (std::out_of_range& e) {
59536       {
59537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59538       };
59539     } catch (std::exception& e) {
59540       {
59541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59542       };
59543     } catch (Dali::DaliException e) {
59544       {
59545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59546       };
59547     } catch (...) {
59548       {
59549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59550       };
59551     }
59552   }
59553
59554   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59555   return jresult;
59556 }
59557
59558
59559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59560   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59561   bool arg2 ;
59562
59563   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59564   arg2 = jarg2 ? true : false;
59565   {
59566     try {
59567       (arg1)->SetKeyboardNavigationSupport(arg2);
59568     } catch (std::out_of_range& e) {
59569       {
59570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59571       };
59572     } catch (std::exception& e) {
59573       {
59574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59575       };
59576     } catch (Dali::DaliException e) {
59577       {
59578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59579       };
59580     } catch (...) {
59581       {
59582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59583       };
59584     }
59585   }
59586
59587 }
59588
59589
59590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59591   unsigned int jresult ;
59592   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59593   bool result;
59594
59595   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59596   {
59597     try {
59598       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59599     } catch (std::out_of_range& e) {
59600       {
59601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59602       };
59603     } catch (std::exception& e) {
59604       {
59605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59606       };
59607     } catch (Dali::DaliException e) {
59608       {
59609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59610       };
59611     } catch (...) {
59612       {
59613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59614       };
59615     }
59616   }
59617
59618   jresult = result;
59619   return jresult;
59620 }
59621
59622
59623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59624   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59625
59626   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59627   {
59628     try {
59629       (arg1)->SetKeyInputFocus();
59630     } catch (std::out_of_range& e) {
59631       {
59632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59633       };
59634     } catch (std::exception& e) {
59635       {
59636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59637       };
59638     } catch (Dali::DaliException e) {
59639       {
59640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59641       };
59642     } catch (...) {
59643       {
59644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59645       };
59646     }
59647   }
59648
59649 }
59650
59651
59652 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
59653   unsigned int jresult ;
59654   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59655   bool result;
59656
59657   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59658   {
59659     try {
59660       result = (bool)(arg1)->HasKeyInputFocus();
59661     } catch (std::out_of_range& e) {
59662       {
59663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59664       };
59665     } catch (std::exception& e) {
59666       {
59667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59668       };
59669     } catch (Dali::DaliException e) {
59670       {
59671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59672       };
59673     } catch (...) {
59674       {
59675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59676       };
59677     }
59678   }
59679
59680   jresult = result;
59681   return jresult;
59682 }
59683
59684
59685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
59686   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59687
59688   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59689   {
59690     try {
59691       (arg1)->ClearKeyInputFocus();
59692     } catch (std::out_of_range& e) {
59693       {
59694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59695       };
59696     } catch (std::exception& e) {
59697       {
59698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59699       };
59700     } catch (Dali::DaliException e) {
59701       {
59702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59703       };
59704     } catch (...) {
59705       {
59706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59707       };
59708     }
59709   }
59710
59711 }
59712
59713
59714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
59715   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59716   bool arg2 ;
59717
59718   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59719   arg2 = jarg2 ? true : false;
59720   {
59721     try {
59722       (arg1)->SetAsKeyboardFocusGroup(arg2);
59723     } catch (std::out_of_range& e) {
59724       {
59725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59726       };
59727     } catch (std::exception& e) {
59728       {
59729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59730       };
59731     } catch (Dali::DaliException e) {
59732       {
59733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59734       };
59735     } catch (...) {
59736       {
59737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59738       };
59739     }
59740   }
59741
59742 }
59743
59744
59745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
59746   unsigned int jresult ;
59747   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59748   bool result;
59749
59750   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59751   {
59752     try {
59753       result = (bool)(arg1)->IsKeyboardFocusGroup();
59754     } catch (std::out_of_range& e) {
59755       {
59756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59757       };
59758     } catch (std::exception& e) {
59759       {
59760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59761       };
59762     } catch (Dali::DaliException e) {
59763       {
59764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59765       };
59766     } catch (...) {
59767       {
59768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59769       };
59770     }
59771   }
59772
59773   jresult = result;
59774   return jresult;
59775 }
59776
59777
59778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59779   void * jresult ;
59780   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59781   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59782
59783   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59784   {
59785     try {
59786       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59787     } catch (std::out_of_range& e) {
59788       {
59789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59790       };
59791     } catch (std::exception& e) {
59792       {
59793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59794       };
59795     } catch (Dali::DaliException e) {
59796       {
59797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59798       };
59799     } catch (...) {
59800       {
59801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59802       };
59803     }
59804   }
59805
59806   jresult = (void *)result;
59807   return jresult;
59808 }
59809
59810
59811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59812   void * jresult ;
59813   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59814   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59815
59816   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59817   {
59818     try {
59819       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59820     } catch (std::out_of_range& e) {
59821       {
59822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59823       };
59824     } catch (std::exception& e) {
59825       {
59826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59827       };
59828     } catch (Dali::DaliException e) {
59829       {
59830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59831       };
59832     } catch (...) {
59833       {
59834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59835       };
59836     }
59837   }
59838
59839   jresult = (void *)result;
59840   return jresult;
59841 }
59842
59843
59844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59845   void * jresult ;
59846   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59847   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59848
59849   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59850   {
59851     try {
59852       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59853     } catch (std::out_of_range& e) {
59854       {
59855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59856       };
59857     } catch (std::exception& e) {
59858       {
59859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59860       };
59861     } catch (Dali::DaliException e) {
59862       {
59863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59864       };
59865     } catch (...) {
59866       {
59867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59868       };
59869     }
59870   }
59871
59872   jresult = (void *)result;
59873   return jresult;
59874 }
59875
59876
59877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnection(void * jarg1, int jarg2) {
59878   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59879   int arg2 ;
59880   SwigDirector_ViewImpl *darg = 0;
59881
59882   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59883   arg2 = (int)jarg2;
59884   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59885   if(!darg) {
59886     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59887     return;
59888   }
59889   {
59890     try {
59891       if(darg) {
59892         (darg)->OnSceneConnection(arg2);
59893       }
59894     } catch (std::out_of_range& e) {
59895       {
59896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59897       };
59898     } catch (std::exception& e) {
59899       {
59900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59901       };
59902     } catch (Dali::DaliException e) {
59903       {
59904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59905       };
59906     } catch (...) {
59907       {
59908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59909       };
59910     }
59911   }
59912
59913 }
59914
59915
59916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
59917   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59918   int arg2 ;
59919   SwigDirector_ViewImpl *darg = 0;
59920
59921   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59922   arg2 = (int)jarg2;
59923   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59924   if(!darg) {
59925     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59926     return;
59927   }
59928   {
59929     try {
59930       if(darg) {
59931         (darg)->OnSceneConnectionSwigPublic(arg2);
59932       }
59933     } catch (std::out_of_range& e) {
59934       {
59935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59936       };
59937     } catch (std::exception& e) {
59938       {
59939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59940       };
59941     } catch (Dali::DaliException e) {
59942       {
59943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59944       };
59945     } catch (...) {
59946       {
59947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59948       };
59949     }
59950   }
59951
59952 }
59953
59954
59955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnection(void * jarg1) {
59956   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59957   SwigDirector_ViewImpl *darg = 0;
59958
59959   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59960   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59961   if(!darg) {
59962     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59963     return;
59964   }
59965   {
59966     try {
59967       if(darg) {
59968         (darg)->OnSceneDisconnection();
59969       }
59970     } catch (std::out_of_range& e) {
59971       {
59972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59973       };
59974     } catch (std::exception& e) {
59975       {
59976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59977       };
59978     } catch (Dali::DaliException e) {
59979       {
59980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59981       };
59982     } catch (...) {
59983       {
59984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59985       };
59986     }
59987   }
59988
59989 }
59990
59991
59992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSceneDisconnectionSwigExplicitViewImpl(void * jarg1) {
59993   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59994   SwigDirector_ViewImpl *darg = 0;
59995
59996   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
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)->OnSceneDisconnectionSwigPublic();
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_OnChildAdd(void * jarg1, void * jarg2) {
60030   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60031   Dali::Actor *arg2 = 0 ;
60032   SwigDirector_ViewImpl *darg = 0;
60033
60034   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60035   arg2 = (Dali::Actor *)jarg2;
60036   if (!arg2) {
60037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60038     return ;
60039   }
60040   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60041   if(!darg) {
60042     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60043     return;
60044   }
60045   {
60046     try {
60047       if(darg) {
60048         (darg)->OnChildAdd(*arg2);
60049       }
60050     } catch (std::out_of_range& e) {
60051       {
60052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60053       };
60054     } catch (std::exception& e) {
60055       {
60056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60057       };
60058     } catch (Dali::DaliException e) {
60059       {
60060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60061       };
60062     } catch (...) {
60063       {
60064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60065       };
60066     }
60067   }
60068
60069 }
60070
60071
60072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60073   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60074   Dali::Actor *arg2 = 0 ;
60075   SwigDirector_ViewImpl *darg = 0;
60076
60077   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60078   arg2 = (Dali::Actor *)jarg2;
60079   if (!arg2) {
60080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60081     return ;
60082   }
60083   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60084   if(!darg) {
60085     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60086     return;
60087   }
60088   {
60089     try {
60090       if(darg) {
60091           (darg)->OnChildAddSwigPublic(*arg2);
60092       }
60093     } catch (std::out_of_range& e) {
60094       {
60095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60096       };
60097     } catch (std::exception& e) {
60098       {
60099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60100       };
60101     } catch (Dali::DaliException e) {
60102       {
60103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60104       };
60105     } catch (...) {
60106       {
60107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60108       };
60109     }
60110   }
60111
60112 }
60113
60114
60115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60117   Dali::Actor *arg2 = 0 ;
60118   SwigDirector_ViewImpl *darg = 0;
60119
60120   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60121   arg2 = (Dali::Actor *)jarg2;
60122   if (!arg2) {
60123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60124     return ;
60125   }
60126   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60127   if(!darg) {
60128     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60129     return;
60130   }
60131   {
60132     try {
60133       if(darg) {
60134         (darg)->OnChildRemove(*arg2);
60135       }
60136     } catch (std::out_of_range& e) {
60137       {
60138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60139       };
60140     } catch (std::exception& e) {
60141       {
60142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60143       };
60144     } catch (Dali::DaliException e) {
60145       {
60146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60147       };
60148     } catch (...) {
60149       {
60150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60151       };
60152     }
60153   }
60154
60155 }
60156
60157
60158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60159   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60160   Dali::Actor *arg2 = 0 ;
60161   SwigDirector_ViewImpl *darg = 0;
60162
60163   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60164   arg2 = (Dali::Actor *)jarg2;
60165   if (!arg2) {
60166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60167     return ;
60168   }
60169   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60170   if(!darg) {
60171     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60172     return;
60173   }
60174   {
60175     try {
60176       if(darg) {
60177         (darg)->OnChildRemoveSwigPublic(*arg2);
60178       }
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_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60202   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60203   Dali::Property::Index arg2 ;
60204   Dali::Property::Value arg3 ;
60205   Dali::Property::Value *argp3 ;
60206   SwigDirector_ViewImpl *darg = 0;
60207
60208   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60209   arg2 = (Dali::Property::Index)jarg2;
60210   argp3 = (Dali::Property::Value *)jarg3;
60211   if (!argp3) {
60212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60213     return ;
60214   }
60215   arg3 = *argp3;
60216   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60217   if (!darg) {
60218     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60219     return;
60220   }
60221   {
60222     try {
60223       (darg)->OnPropertySet(arg2,arg3);
60224     } catch (std::out_of_range& e) {
60225       {
60226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60227       };
60228     } catch (std::exception& e) {
60229       {
60230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60231       };
60232     } catch (Dali::DaliException e) {
60233       {
60234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60235       };
60236     } catch (...) {
60237       {
60238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60239       };
60240     }
60241   }
60242
60243 }
60244
60245
60246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60247   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60248   Dali::Property::Index arg2 ;
60249   Dali::Property::Value arg3 ;
60250   Dali::Property::Value *argp3 ;
60251   SwigDirector_ViewImpl *darg = 0;
60252
60253   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60254   arg2 = (Dali::Property::Index)jarg2;
60255   argp3 = (Dali::Property::Value *)jarg3;
60256   if (!argp3) {
60257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60258     return ;
60259   }
60260   arg3 = *argp3;
60261   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60262   if (!darg) {
60263     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60264     return;
60265   }
60266   {
60267     try {
60268       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60269     } catch (std::out_of_range& e) {
60270       {
60271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60272       };
60273     } catch (std::exception& e) {
60274       {
60275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60276       };
60277     } catch (Dali::DaliException e) {
60278       {
60279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60280       };
60281     } catch (...) {
60282       {
60283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60284       };
60285     }
60286   }
60287
60288 }
60289
60290
60291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60292   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60293   Dali::Vector3 *arg2 = 0 ;
60294   SwigDirector_ViewImpl *darg = 0;
60295
60296   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60297   arg2 = (Dali::Vector3 *)jarg2;
60298   if (!arg2) {
60299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60300     return ;
60301   }
60302   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60303   if (!darg) {
60304     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60305     return;
60306   }
60307   {
60308     try {
60309       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60310     } catch (std::out_of_range& e) {
60311       {
60312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60313       };
60314     } catch (std::exception& e) {
60315       {
60316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60317       };
60318     } catch (Dali::DaliException e) {
60319       {
60320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60321       };
60322     } catch (...) {
60323       {
60324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60325       };
60326     }
60327   }
60328
60329 }
60330
60331
60332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60333   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60334   Dali::Vector3 *arg2 = 0 ;
60335   SwigDirector_ViewImpl *darg = 0;
60336
60337   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60338   arg2 = (Dali::Vector3 *)jarg2;
60339   if (!arg2) {
60340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60341     return ;
60342   }
60343   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60344   if (!darg) {
60345     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60346     return;
60347   }
60348   {
60349     try {
60350       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60351     } catch (std::out_of_range& e) {
60352       {
60353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60354       };
60355     } catch (std::exception& e) {
60356       {
60357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60358       };
60359     } catch (Dali::DaliException e) {
60360       {
60361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60362       };
60363     } catch (...) {
60364       {
60365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60366       };
60367     }
60368   }
60369
60370 }
60371
60372
60373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60375   Dali::Animation *arg2 = 0 ;
60376   Dali::Vector3 *arg3 = 0 ;
60377   SwigDirector_ViewImpl *darg = 0;
60378
60379   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60380   arg2 = (Dali::Animation *)jarg2;
60381   if (!arg2) {
60382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60383     return ;
60384   }
60385   arg3 = (Dali::Vector3 *)jarg3;
60386   if (!arg3) {
60387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60388     return ;
60389   }
60390   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60391   if (!darg) {
60392     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60393     return;
60394   }
60395   {
60396     try {
60397       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60398     } catch (std::out_of_range& e) {
60399       {
60400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60401       };
60402     } catch (std::exception& e) {
60403       {
60404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60405       };
60406     } catch (Dali::DaliException e) {
60407       {
60408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60409       };
60410     } catch (...) {
60411       {
60412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60413       };
60414     }
60415   }
60416
60417 }
60418
60419
60420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60421   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60422   Dali::Animation *arg2 = 0 ;
60423   Dali::Vector3 *arg3 = 0 ;
60424   SwigDirector_ViewImpl *darg = 0;
60425
60426   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60427   arg2 = (Dali::Animation *)jarg2;
60428   if (!arg2) {
60429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60430     return ;
60431   }
60432   arg3 = (Dali::Vector3 *)jarg3;
60433   if (!arg3) {
60434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60435     return ;
60436   }
60437   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60438   if (!darg) {
60439     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60440     return;
60441   }
60442   {
60443     try {
60444       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60445     } catch (std::out_of_range& e) {
60446       {
60447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60448       };
60449     } catch (std::exception& e) {
60450       {
60451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60452       };
60453     } catch (Dali::DaliException e) {
60454       {
60455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60456       };
60457     } catch (...) {
60458       {
60459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60460       };
60461     }
60462   }
60463 }
60464
60465
60466 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60467   unsigned int jresult ;
60468   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60469   Dali::HoverEvent *arg2 = 0 ;
60470   SwigDirector_ViewImpl *darg = 0;
60471   bool result;
60472
60473   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60474   arg2 = (Dali::HoverEvent *)jarg2;
60475   if (!arg2) {
60476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60477     return 0;
60478   }
60479   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60480   if (!darg) {
60481     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60482     return 0;
60483   }
60484   {
60485     try {
60486       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60487     } catch (std::out_of_range& e) {
60488       {
60489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60490       };
60491     } catch (std::exception& e) {
60492       {
60493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60494       };
60495     } catch (Dali::DaliException e) {
60496       {
60497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60498       };
60499     } catch (...) {
60500       {
60501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60502       };
60503     }
60504   }
60505
60506   jresult = result;
60507   return jresult;
60508 }
60509
60510
60511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60512   unsigned int jresult ;
60513   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60514   Dali::HoverEvent *arg2 = 0 ;
60515   SwigDirector_ViewImpl *darg = 0;
60516   bool result;
60517
60518   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60519   arg2 = (Dali::HoverEvent *)jarg2;
60520   if (!arg2) {
60521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60522     return 0;
60523   }
60524   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60525   if (!darg) {
60526     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60527     return 0;
60528   }
60529   {
60530     try {
60531       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60532     } catch (std::out_of_range& e) {
60533       {
60534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60535       };
60536     } catch (std::exception& e) {
60537       {
60538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60539       };
60540     } catch (Dali::DaliException e) {
60541       {
60542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60543       };
60544     } catch (...) {
60545       {
60546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60547       };
60548     }
60549   }
60550
60551   jresult = result;
60552   return jresult;
60553 }
60554
60555
60556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60557   unsigned int jresult ;
60558   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60559   Dali::KeyEvent *arg2 = 0 ;
60560   SwigDirector_ViewImpl *darg = 0;
60561   bool result;
60562
60563   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60564   arg2 = (Dali::KeyEvent *)jarg2;
60565   if (!arg2) {
60566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60567     return 0;
60568   }
60569   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60570   if (!darg) {
60571     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60572     return 0;
60573   }
60574   {
60575     try {
60576       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60577     } catch (std::out_of_range& e) {
60578       {
60579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60580       };
60581     } catch (std::exception& e) {
60582       {
60583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60584       };
60585     } catch (Dali::DaliException e) {
60586       {
60587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60588       };
60589     } catch (...) {
60590       {
60591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60592       };
60593     }
60594   }
60595
60596   jresult = result;
60597   return jresult;
60598 }
60599
60600
60601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60602   unsigned int jresult ;
60603   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60604   Dali::KeyEvent *arg2 = 0 ;
60605   SwigDirector_ViewImpl *darg = 0;
60606   bool result;
60607
60608   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60609   arg2 = (Dali::KeyEvent *)jarg2;
60610   if (!arg2) {
60611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60612     return 0;
60613   }
60614   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60615   if (!darg) {
60616     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60617     return 0;
60618   }
60619   {
60620     try {
60621       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60622     } catch (std::out_of_range& e) {
60623       {
60624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60625       };
60626     } catch (std::exception& e) {
60627       {
60628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60629       };
60630     } catch (Dali::DaliException e) {
60631       {
60632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60633       };
60634     } catch (...) {
60635       {
60636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60637       };
60638     }
60639   }
60640
60641   jresult = result;
60642   return jresult;
60643 }
60644
60645
60646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60647   unsigned int jresult ;
60648   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60649   Dali::WheelEvent *arg2 = 0 ;
60650   SwigDirector_ViewImpl *darg = 0;
60651   bool result;
60652
60653   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60654   arg2 = (Dali::WheelEvent *)jarg2;
60655   if (!arg2) {
60656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60657     return 0;
60658   }
60659   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60660   if (!darg) {
60661     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60662     return 0;
60663   }
60664   {
60665     try {
60666       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
60667     } catch (std::out_of_range& e) {
60668       {
60669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60670       };
60671     } catch (std::exception& e) {
60672       {
60673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60674       };
60675     } catch (Dali::DaliException e) {
60676       {
60677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60678       };
60679     } catch (...) {
60680       {
60681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60682       };
60683     }
60684   }
60685
60686   jresult = result;
60687   return jresult;
60688 }
60689
60690
60691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60692   unsigned int jresult ;
60693   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60694   Dali::WheelEvent *arg2 = 0 ;
60695   SwigDirector_ViewImpl *darg = 0;
60696   bool result;
60697
60698   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60699   arg2 = (Dali::WheelEvent *)jarg2;
60700   if (!arg2) {
60701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60702     return 0;
60703   }
60704   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60705   if (!darg) {
60706     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60707     return 0;
60708   }
60709   {
60710     try {
60711       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
60712     } catch (std::out_of_range& e) {
60713       {
60714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60715       };
60716     } catch (std::exception& e) {
60717       {
60718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60719       };
60720     } catch (Dali::DaliException e) {
60721       {
60722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60723       };
60724     } catch (...) {
60725       {
60726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60727       };
60728     }
60729   }
60730
60731   jresult = result;
60732   return jresult;
60733 }
60734
60735
60736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
60737   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60738   Dali::Vector2 *arg2 = 0 ;
60739   Dali::RelayoutContainer *arg3 = 0 ;
60740   SwigDirector_ViewImpl *darg = 0;
60741
60742   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60743   arg2 = (Dali::Vector2 *)jarg2;
60744   if (!arg2) {
60745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60746     return ;
60747   }
60748   arg3 = (Dali::RelayoutContainer *)jarg3;
60749   if (!arg3) {
60750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60751     return ;
60752   }
60753   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60754   if (!darg) {
60755     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60756     return;
60757   }
60758   {
60759     try {
60760       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
60761     } catch (std::out_of_range& e) {
60762       {
60763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60764       };
60765     } catch (std::exception& e) {
60766       {
60767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60768       };
60769     } catch (Dali::DaliException e) {
60770       {
60771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60772       };
60773     } catch (...) {
60774       {
60775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60776       };
60777     }
60778   }
60779
60780 }
60781
60782
60783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60784   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60785   Dali::Vector2 *arg2 = 0 ;
60786   Dali::RelayoutContainer *arg3 = 0 ;
60787   SwigDirector_ViewImpl *darg = 0;
60788
60789   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60790   arg2 = (Dali::Vector2 *)jarg2;
60791   if (!arg2) {
60792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60793     return ;
60794   }
60795   arg3 = (Dali::RelayoutContainer *)jarg3;
60796   if (!arg3) {
60797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60798     return ;
60799   }
60800   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60801   if (!darg) {
60802     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60803     return;
60804   }
60805   {
60806     try {
60807       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
60808     } catch (std::out_of_range& e) {
60809       {
60810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60811       };
60812     } catch (std::exception& e) {
60813       {
60814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60815       };
60816     } catch (Dali::DaliException e) {
60817       {
60818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60819       };
60820     } catch (...) {
60821       {
60822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60823       };
60824     }
60825   }
60826
60827 }
60828
60829
60830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
60831   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60832   Dali::ResizePolicy::Type arg2 ;
60833   Dali::Dimension::Type arg3 ;
60834   SwigDirector_ViewImpl *darg = 0;
60835
60836   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60837   arg2 = (Dali::ResizePolicy::Type)jarg2;
60838   arg3 = (Dali::Dimension::Type)jarg3;
60839   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60840   if (!darg) {
60841     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60842     return;
60843   }
60844   {
60845     try {
60846       (darg)->OnSetResizePolicy(arg2,arg3);
60847     } catch (std::out_of_range& e) {
60848       {
60849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60850       };
60851     } catch (std::exception& e) {
60852       {
60853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60854       };
60855     } catch (Dali::DaliException e) {
60856       {
60857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60858       };
60859     } catch (...) {
60860       {
60861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60862       };
60863     }
60864   }
60865
60866 }
60867
60868
60869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
60870   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60871   Dali::ResizePolicy::Type arg2 ;
60872   Dali::Dimension::Type arg3 ;
60873   SwigDirector_ViewImpl *darg = 0;
60874
60875   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60876   arg2 = (Dali::ResizePolicy::Type)jarg2;
60877   arg3 = (Dali::Dimension::Type)jarg3;
60878   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60879   if (!darg) {
60880     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60881     return;
60882   }
60883   {
60884     try {
60885       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
60886     } catch (std::out_of_range& e) {
60887       {
60888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60889       };
60890     } catch (std::exception& e) {
60891       {
60892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60893       };
60894     } catch (Dali::DaliException e) {
60895       {
60896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60897       };
60898     } catch (...) {
60899       {
60900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60901       };
60902     }
60903   }
60904
60905 }
60906
60907
60908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
60909   void * jresult ;
60910   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60911   SwigDirector_ViewImpl *darg = 0;
60912   Dali::Vector3 result;
60913
60914   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60915   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60916   if (!darg) {
60917     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60918     return 0;
60919   }
60920   {
60921     try {
60922       result = (darg)->GetNaturalSize();
60923     } catch (std::out_of_range& e) {
60924       {
60925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60926       };
60927     } catch (std::exception& e) {
60928       {
60929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60930       };
60931     } catch (Dali::DaliException e) {
60932       {
60933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60934       };
60935     } catch (...) {
60936       {
60937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60938       };
60939     }
60940   }
60941
60942   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60943   return jresult;
60944 }
60945
60946
60947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
60948   void * jresult ;
60949   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60950   SwigDirector_ViewImpl *darg = 0;
60951   Dali::Vector3 result;
60952
60953   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60954   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60955   if (!darg) {
60956     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60957     return 0;
60958   }
60959   {
60960     try {
60961       result = (darg)->GetNaturalSizeSwigPublic();
60962     } catch (std::out_of_range& e) {
60963       {
60964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60965       };
60966     } catch (std::exception& e) {
60967       {
60968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60969       };
60970     } catch (Dali::DaliException e) {
60971       {
60972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60973       };
60974     } catch (...) {
60975       {
60976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60977       };
60978     }
60979   }
60980
60981   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60982   return jresult;
60983 }
60984
60985
60986 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
60987   float jresult ;
60988   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60989   Dali::Actor *arg2 = 0 ;
60990   Dali::Dimension::Type arg3 ;
60991   SwigDirector_ViewImpl *darg = 0;
60992   float result;
60993
60994   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60995   arg2 = (Dali::Actor *)jarg2;
60996   if (!arg2) {
60997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60998     return 0;
60999   }
61000   arg3 = (Dali::Dimension::Type)jarg3;
61001   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61002   if (!darg) {
61003     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61004     return 0;
61005   }
61006   {
61007     try {
61008       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61009     } catch (std::out_of_range& e) {
61010       {
61011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61012       };
61013     } catch (std::exception& e) {
61014       {
61015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61016       };
61017     } catch (Dali::DaliException e) {
61018       {
61019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61020       };
61021     } catch (...) {
61022       {
61023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61024       };
61025     }
61026   }
61027
61028   jresult = result;
61029   return jresult;
61030 }
61031
61032
61033 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61034   float jresult ;
61035   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61036   Dali::Actor *arg2 = 0 ;
61037   Dali::Dimension::Type arg3 ;
61038   SwigDirector_ViewImpl *darg = 0;
61039   float result;
61040
61041   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61042   arg2 = (Dali::Actor *)jarg2;
61043   if (!arg2) {
61044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61045     return 0;
61046   }
61047   arg3 = (Dali::Dimension::Type)jarg3;
61048   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61049   if (!darg) {
61050     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61051     return 0;
61052   }
61053   {
61054     try {
61055       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61056     } catch (std::out_of_range& e) {
61057       {
61058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61059       };
61060     } catch (std::exception& e) {
61061       {
61062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61063       };
61064     } catch (Dali::DaliException e) {
61065       {
61066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61067       };
61068     } catch (...) {
61069       {
61070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61071       };
61072     }
61073   }
61074
61075   jresult = result;
61076   return jresult;
61077 }
61078
61079
61080 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61081   float jresult ;
61082   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61083   float arg2 ;
61084   SwigDirector_ViewImpl *darg = 0;
61085   float result;
61086
61087   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61088   arg2 = (float)jarg2;
61089   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61090   if (!darg) {
61091     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61092     return 0;
61093   }
61094   {
61095     try {
61096       result = (float)(darg)->GetHeightForWidth(arg2);
61097     } catch (std::out_of_range& e) {
61098       {
61099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61100       };
61101     } catch (std::exception& e) {
61102       {
61103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61104       };
61105     } catch (Dali::DaliException e) {
61106       {
61107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61108       };
61109     } catch (...) {
61110       {
61111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61112       };
61113     }
61114   }
61115
61116   jresult = result;
61117   return jresult;
61118 }
61119
61120
61121 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61122   float jresult ;
61123   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61124   float arg2 ;
61125   SwigDirector_ViewImpl *darg = 0;
61126   float result;
61127
61128   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61129   arg2 = (float)jarg2;
61130   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61131   if (!darg) {
61132     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61133     return 0;
61134   }
61135   {
61136     try {
61137       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61138     } catch (std::out_of_range& e) {
61139       {
61140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61141       };
61142     } catch (std::exception& e) {
61143       {
61144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61145       };
61146     } catch (Dali::DaliException e) {
61147       {
61148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61149       };
61150     } catch (...) {
61151       {
61152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61153       };
61154     }
61155   }
61156
61157   jresult = result;
61158   return jresult;
61159 }
61160
61161
61162 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61163   float jresult ;
61164   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61165   float arg2 ;
61166   SwigDirector_ViewImpl *darg = 0;
61167   float result;
61168
61169   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61170   arg2 = (float)jarg2;
61171   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61172   if (!darg) {
61173     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61174     return 0;
61175   }
61176   {
61177     try {
61178       result = (float)(darg)->GetWidthForHeight(arg2);
61179     } catch (std::out_of_range& e) {
61180       {
61181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61182       };
61183     } catch (std::exception& e) {
61184       {
61185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61186       };
61187     } catch (Dali::DaliException e) {
61188       {
61189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61190       };
61191     } catch (...) {
61192       {
61193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61194       };
61195     }
61196   }
61197
61198   jresult = result;
61199   return jresult;
61200 }
61201
61202
61203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61204   float jresult ;
61205   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61206   float arg2 ;
61207   SwigDirector_ViewImpl *darg = 0;
61208   float result;
61209
61210   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61211   arg2 = (float)jarg2;
61212   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61213   if (!darg) {
61214     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61215     return 0;
61216   }
61217   {
61218     try {
61219       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61220     } catch (std::out_of_range& e) {
61221       {
61222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61223       };
61224     } catch (std::exception& e) {
61225       {
61226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61227       };
61228     } catch (Dali::DaliException e) {
61229       {
61230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61231       };
61232     } catch (...) {
61233       {
61234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61235       };
61236     }
61237   }
61238
61239   jresult = result;
61240   return jresult;
61241 }
61242
61243
61244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61245   unsigned int jresult ;
61246   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61247   Dali::Dimension::Type arg2 ;
61248   SwigDirector_ViewImpl *darg = 0;
61249   bool result;
61250
61251   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61252   arg2 = (Dali::Dimension::Type)jarg2;
61253   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61254   if (!darg) {
61255     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61256     return 0;
61257   }
61258   {
61259     try {
61260       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61261     } catch (std::out_of_range& e) {
61262       {
61263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61264       };
61265     } catch (std::exception& e) {
61266       {
61267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61268       };
61269     } catch (Dali::DaliException e) {
61270       {
61271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61272       };
61273     } catch (...) {
61274       {
61275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61276       };
61277     }
61278   }
61279
61280   jresult = result;
61281   return jresult;
61282 }
61283
61284
61285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61286   unsigned int jresult ;
61287   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61288   Dali::Dimension::Type arg2 ;
61289   SwigDirector_ViewImpl *darg = 0;
61290   bool result;
61291
61292   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61293   arg2 = (Dali::Dimension::Type)jarg2;
61294   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61295   if (!darg) {
61296     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61297     return 0;
61298   }
61299   {
61300     try {
61301       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61302     } catch (std::out_of_range& e) {
61303       {
61304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61305       };
61306     } catch (std::exception& e) {
61307       {
61308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61309       };
61310     } catch (Dali::DaliException e) {
61311       {
61312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61313       };
61314     } catch (...) {
61315       {
61316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61317       };
61318     }
61319   }
61320
61321   jresult = result;
61322   return jresult;
61323 }
61324
61325
61326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61327   unsigned int jresult ;
61328   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61329   SwigDirector_ViewImpl *darg = 0;
61330   bool result;
61331
61332   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61333   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61334   if (!darg) {
61335     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61336     return 0;
61337   }
61338   {
61339     try {
61340       result = (bool)(darg)->RelayoutDependentOnChildren();
61341     } catch (std::out_of_range& e) {
61342       {
61343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61344       };
61345     } catch (std::exception& e) {
61346       {
61347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61348       };
61349     } catch (Dali::DaliException e) {
61350       {
61351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61352       };
61353     } catch (...) {
61354       {
61355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61356       };
61357     }
61358   }
61359
61360   jresult = result;
61361   return jresult;
61362 }
61363
61364
61365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61366   unsigned int jresult ;
61367   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61368   SwigDirector_ViewImpl *darg = 0;
61369   bool result;
61370
61371   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61372   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61373   if (!darg) {
61374     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61375     return 0;
61376   }
61377   {
61378     try {
61379       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61380     } catch (std::out_of_range& e) {
61381       {
61382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61383       };
61384     } catch (std::exception& e) {
61385       {
61386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61387       };
61388     } catch (Dali::DaliException e) {
61389       {
61390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61391       };
61392     } catch (...) {
61393       {
61394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61395       };
61396     }
61397   }
61398
61399   jresult = result;
61400   return jresult;
61401 }
61402
61403
61404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61405   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61406   Dali::Dimension::Type arg2 ;
61407   SwigDirector_ViewImpl *darg = 0;
61408
61409   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61410   arg2 = (Dali::Dimension::Type)jarg2;
61411   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61412   if (!darg) {
61413     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61414     return;
61415   }
61416   {
61417     try {
61418       (darg)->OnCalculateRelayoutSize(arg2);
61419     } catch (std::out_of_range& e) {
61420       {
61421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61422       };
61423     } catch (std::exception& e) {
61424       {
61425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61426       };
61427     } catch (Dali::DaliException e) {
61428       {
61429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61430       };
61431     } catch (...) {
61432       {
61433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61434       };
61435     }
61436   }
61437
61438 }
61439
61440
61441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61442   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61443   Dali::Dimension::Type arg2 ;
61444   SwigDirector_ViewImpl *darg = 0;
61445
61446   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61447   arg2 = (Dali::Dimension::Type)jarg2;
61448   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61449   if (!darg) {
61450     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61451     return;
61452   }
61453   {
61454     try {
61455       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61456     } catch (std::out_of_range& e) {
61457       {
61458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61459       };
61460     } catch (std::exception& e) {
61461       {
61462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61463       };
61464     } catch (Dali::DaliException e) {
61465       {
61466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61467       };
61468     } catch (...) {
61469       {
61470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61471       };
61472     }
61473   }
61474
61475 }
61476
61477
61478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61479   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61480   float arg2 ;
61481   Dali::Dimension::Type arg3 ;
61482   SwigDirector_ViewImpl *darg = 0;
61483
61484   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61485   arg2 = (float)jarg2;
61486   arg3 = (Dali::Dimension::Type)jarg3;
61487   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61488   if (!darg) {
61489     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61490     return;
61491   }
61492   {
61493     try {
61494       (darg)->OnLayoutNegotiated(arg2,arg3);
61495     } catch (std::out_of_range& e) {
61496       {
61497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61498       };
61499     } catch (std::exception& e) {
61500       {
61501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61502       };
61503     } catch (Dali::DaliException e) {
61504       {
61505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61506       };
61507     } catch (...) {
61508       {
61509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61510       };
61511     }
61512   }
61513
61514 }
61515
61516
61517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61518   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61519   float arg2 ;
61520   Dali::Dimension::Type arg3 ;
61521   SwigDirector_ViewImpl *darg = 0;
61522
61523   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61524   arg2 = (float)jarg2;
61525   arg3 = (Dali::Dimension::Type)jarg3;
61526   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61527   if (!darg) {
61528     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61529     return;
61530   }
61531   {
61532     try {
61533       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61534     } catch (std::out_of_range& e) {
61535       {
61536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61537       };
61538     } catch (std::exception& e) {
61539       {
61540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61541       };
61542     } catch (Dali::DaliException e) {
61543       {
61544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61545       };
61546     } catch (...) {
61547       {
61548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61549       };
61550     }
61551   }
61552
61553 }
61554
61555
61556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
61557   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61558
61559   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61560   {
61561     try {
61562       (arg1)->OnInitialize();
61563     } catch (std::out_of_range& e) {
61564       {
61565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61566       };
61567     } catch (std::exception& e) {
61568       {
61569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61570       };
61571     } catch (Dali::DaliException e) {
61572       {
61573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61574       };
61575     } catch (...) {
61576       {
61577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61578       };
61579     }
61580   }
61581
61582 }
61583
61584
61585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61586   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61587
61588   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61589   {
61590     try {
61591       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61592     } catch (std::out_of_range& e) {
61593       {
61594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61595       };
61596     } catch (std::exception& e) {
61597       {
61598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61599       };
61600     } catch (Dali::DaliException e) {
61601       {
61602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61603       };
61604     } catch (...) {
61605       {
61606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61607       };
61608     }
61609   }
61610
61611 }
61612
61613
61614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61615   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61616   Dali::Toolkit::StyleManager arg2 ;
61617   Dali::StyleChange::Type arg3 ;
61618   Dali::Toolkit::StyleManager *argp2 ;
61619
61620   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61621   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61622   if (!argp2) {
61623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61624     return ;
61625   }
61626   arg2 = *argp2;
61627   arg3 = (Dali::StyleChange::Type)jarg3;
61628   {
61629     try {
61630       (arg1)->OnStyleChange(arg2,arg3);
61631     } catch (std::out_of_range& e) {
61632       {
61633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61634       };
61635     } catch (std::exception& e) {
61636       {
61637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61638       };
61639     } catch (Dali::DaliException e) {
61640       {
61641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61642       };
61643     } catch (...) {
61644       {
61645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61646       };
61647     }
61648   }
61649
61650 }
61651
61652
61653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61654   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61655   Dali::Toolkit::StyleManager arg2 ;
61656   Dali::StyleChange::Type arg3 ;
61657   Dali::Toolkit::StyleManager *argp2 ;
61658
61659   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61660   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61661   if (!argp2) {
61662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61663     return ;
61664   }
61665   arg2 = *argp2;
61666   arg3 = (Dali::StyleChange::Type)jarg3;
61667   {
61668     try {
61669       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61670     } catch (std::out_of_range& e) {
61671       {
61672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61673       };
61674     } catch (std::exception& e) {
61675       {
61676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61677       };
61678     } catch (Dali::DaliException e) {
61679       {
61680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61681       };
61682     } catch (...) {
61683       {
61684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61685       };
61686     }
61687   }
61688
61689 }
61690
61691
61692 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
61693   unsigned int jresult ;
61694   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61695   bool result;
61696
61697   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61698   {
61699     try {
61700       result = (bool)(arg1)->OnAccessibilityActivated();
61701     } catch (std::out_of_range& e) {
61702       {
61703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61704       };
61705     } catch (std::exception& e) {
61706       {
61707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61708       };
61709     } catch (Dali::DaliException e) {
61710       {
61711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61712       };
61713     } catch (...) {
61714       {
61715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61716       };
61717     }
61718   }
61719
61720   jresult = result;
61721   return jresult;
61722 }
61723
61724
61725 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
61726   unsigned int jresult ;
61727   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61728   bool result;
61729
61730   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61731   {
61732     try {
61733       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
61734     } catch (std::out_of_range& e) {
61735       {
61736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61737       };
61738     } catch (std::exception& e) {
61739       {
61740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61741       };
61742     } catch (Dali::DaliException e) {
61743       {
61744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61745       };
61746     } catch (...) {
61747       {
61748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61749       };
61750     }
61751   }
61752
61753   jresult = result;
61754   return jresult;
61755 }
61756
61757
61758 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
61759   unsigned int jresult ;
61760   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61761   Dali::PanGesture arg2 ;
61762   Dali::PanGesture *argp2 ;
61763   bool result;
61764
61765   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61766   argp2 = (Dali::PanGesture *)jarg2;
61767   if (!argp2) {
61768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61769     return 0;
61770   }
61771   arg2 = *argp2;
61772   {
61773     try {
61774       result = (bool)(arg1)->OnAccessibilityPan(arg2);
61775     } catch (std::out_of_range& e) {
61776       {
61777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61778       };
61779     } catch (std::exception& e) {
61780       {
61781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61782       };
61783     } catch (Dali::DaliException e) {
61784       {
61785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61786       };
61787     } catch (...) {
61788       {
61789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61790       };
61791     }
61792   }
61793
61794   jresult = result;
61795   return jresult;
61796 }
61797
61798
61799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61800   unsigned int jresult ;
61801   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61802   Dali::PanGesture arg2 ;
61803   Dali::PanGesture *argp2 ;
61804   bool result;
61805
61806   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61807   argp2 = (Dali::PanGesture *)jarg2;
61808   if (!argp2) {
61809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61810     return 0;
61811   }
61812   arg2 = *argp2;
61813   {
61814     try {
61815       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
61816     } catch (std::out_of_range& e) {
61817       {
61818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61819       };
61820     } catch (std::exception& e) {
61821       {
61822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61823       };
61824     } catch (Dali::DaliException e) {
61825       {
61826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61827       };
61828     } catch (...) {
61829       {
61830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61831       };
61832     }
61833   }
61834
61835   jresult = result;
61836   return jresult;
61837 }
61838
61839
61840
61841
61842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
61843   unsigned int jresult ;
61844   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61845   bool arg2 ;
61846   bool result;
61847
61848   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61849   arg2 = jarg2 ? true : false;
61850   {
61851     try {
61852       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
61853     } catch (std::out_of_range& e) {
61854       {
61855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61856       };
61857     } catch (std::exception& e) {
61858       {
61859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61860       };
61861     } catch (Dali::DaliException e) {
61862       {
61863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61864       };
61865     } catch (...) {
61866       {
61867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61868       };
61869     }
61870   }
61871
61872   jresult = result;
61873   return jresult;
61874 }
61875
61876
61877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
61878   unsigned int jresult ;
61879   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61880   bool arg2 ;
61881   bool result;
61882
61883   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61884   arg2 = jarg2 ? true : false;
61885   {
61886     try {
61887       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
61888     } catch (std::out_of_range& e) {
61889       {
61890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61891       };
61892     } catch (std::exception& e) {
61893       {
61894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61895       };
61896     } catch (Dali::DaliException e) {
61897       {
61898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61899       };
61900     } catch (...) {
61901       {
61902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61903       };
61904     }
61905   }
61906
61907   jresult = result;
61908   return jresult;
61909 }
61910
61911
61912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
61913   unsigned int jresult ;
61914   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61915   bool result;
61916
61917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61918   {
61919     try {
61920       result = (bool)(arg1)->OnAccessibilityZoom();
61921     } catch (std::out_of_range& e) {
61922       {
61923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61924       };
61925     } catch (std::exception& e) {
61926       {
61927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61928       };
61929     } catch (Dali::DaliException e) {
61930       {
61931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61932       };
61933     } catch (...) {
61934       {
61935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61936       };
61937     }
61938   }
61939
61940   jresult = result;
61941   return jresult;
61942 }
61943
61944
61945 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
61946   unsigned int jresult ;
61947   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61948   bool result;
61949
61950   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61951   {
61952     try {
61953       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
61954     } catch (std::out_of_range& e) {
61955       {
61956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61957       };
61958     } catch (std::exception& e) {
61959       {
61960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61961       };
61962     } catch (Dali::DaliException e) {
61963       {
61964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61965       };
61966     } catch (...) {
61967       {
61968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61969       };
61970     }
61971   }
61972
61973   jresult = result;
61974   return jresult;
61975 }
61976
61977
61978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
61979   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61980
61981   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61982   {
61983     try {
61984       (arg1)->OnKeyInputFocusGained();
61985     } catch (std::out_of_range& e) {
61986       {
61987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61988       };
61989     } catch (std::exception& e) {
61990       {
61991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61992       };
61993     } catch (Dali::DaliException e) {
61994       {
61995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61996       };
61997     } catch (...) {
61998       {
61999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62000       };
62001     }
62002   }
62003
62004 }
62005
62006
62007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62008   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62009
62010   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62011   {
62012     try {
62013       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62014     } catch (std::out_of_range& e) {
62015       {
62016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62017       };
62018     } catch (std::exception& e) {
62019       {
62020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62021       };
62022     } catch (Dali::DaliException e) {
62023       {
62024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62025       };
62026     } catch (...) {
62027       {
62028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62029       };
62030     }
62031   }
62032
62033 }
62034
62035
62036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62037   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62038
62039   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62040   {
62041     try {
62042       (arg1)->OnKeyInputFocusLost();
62043     } catch (std::out_of_range& e) {
62044       {
62045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62046       };
62047     } catch (std::exception& e) {
62048       {
62049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62050       };
62051     } catch (Dali::DaliException e) {
62052       {
62053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62054       };
62055     } catch (...) {
62056       {
62057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62058       };
62059     }
62060   }
62061
62062 }
62063
62064
62065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62066   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62067
62068   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62069   {
62070     try {
62071       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62072     } catch (std::out_of_range& e) {
62073       {
62074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62075       };
62076     } catch (std::exception& e) {
62077       {
62078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62079       };
62080     } catch (Dali::DaliException e) {
62081       {
62082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62083       };
62084     } catch (...) {
62085       {
62086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62087       };
62088     }
62089   }
62090
62091 }
62092
62093
62094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62095   void * jresult ;
62096   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62097   Dali::Actor arg2 ;
62098   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62099   bool arg4 ;
62100   Dali::Actor *argp2 ;
62101   Dali::Actor result;
62102
62103   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62104   argp2 = (Dali::Actor *)jarg2;
62105   if (!argp2) {
62106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62107     return 0;
62108   }
62109   arg2 = *argp2;
62110   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62111   arg4 = jarg4 ? true : false;
62112   {
62113     try {
62114       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62115     } catch (std::out_of_range& e) {
62116       {
62117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62118       };
62119     } catch (std::exception& e) {
62120       {
62121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62122       };
62123     } catch (Dali::DaliException e) {
62124       {
62125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62126       };
62127     } catch (...) {
62128       {
62129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62130       };
62131     }
62132   }
62133
62134   jresult = new Dali::Actor((const Dali::Actor &)result);
62135   return jresult;
62136 }
62137
62138
62139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62140   void * jresult ;
62141   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62142   Dali::Actor arg2 ;
62143   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62144   bool arg4 ;
62145   Dali::Actor *argp2 ;
62146   Dali::Actor result;
62147
62148   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62149   argp2 = (Dali::Actor *)jarg2;
62150   if (!argp2) {
62151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62152     return 0;
62153   }
62154   arg2 = *argp2;
62155   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62156   arg4 = jarg4 ? true : false;
62157   {
62158     try {
62159       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62160     } catch (std::out_of_range& e) {
62161       {
62162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62163       };
62164     } catch (std::exception& e) {
62165       {
62166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62167       };
62168     } catch (Dali::DaliException e) {
62169       {
62170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62171       };
62172     } catch (...) {
62173       {
62174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62175       };
62176     }
62177   }
62178
62179   jresult = new Dali::Actor((const Dali::Actor &)result);
62180   return jresult;
62181 }
62182
62183
62184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62185   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62186   Dali::Actor arg2 ;
62187   Dali::Actor *argp2 ;
62188
62189   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62190   argp2 = (Dali::Actor *)jarg2;
62191   if (!argp2) {
62192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62193     return ;
62194   }
62195   arg2 = *argp2;
62196   {
62197     try {
62198       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62199     } catch (std::out_of_range& e) {
62200       {
62201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62202       };
62203     } catch (std::exception& e) {
62204       {
62205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62206       };
62207     } catch (Dali::DaliException e) {
62208       {
62209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62210       };
62211     } catch (...) {
62212       {
62213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62214       };
62215     }
62216   }
62217
62218 }
62219
62220
62221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62222   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62223   Dali::Actor arg2 ;
62224   Dali::Actor *argp2 ;
62225
62226   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62227   argp2 = (Dali::Actor *)jarg2;
62228   if (!argp2) {
62229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62230     return ;
62231   }
62232   arg2 = *argp2;
62233   {
62234     try {
62235       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62236     } catch (std::out_of_range& e) {
62237       {
62238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62239       };
62240     } catch (std::exception& e) {
62241       {
62242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62243       };
62244     } catch (Dali::DaliException e) {
62245       {
62246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62247       };
62248     } catch (...) {
62249       {
62250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62251       };
62252     }
62253   }
62254
62255 }
62256
62257
62258 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62259   unsigned int jresult ;
62260   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62261   bool result;
62262
62263   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62264   {
62265     try {
62266       result = (bool)(arg1)->OnKeyboardEnter();
62267     } catch (std::out_of_range& e) {
62268       {
62269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62270       };
62271     } catch (std::exception& e) {
62272       {
62273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62274       };
62275     } catch (Dali::DaliException e) {
62276       {
62277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62278       };
62279     } catch (...) {
62280       {
62281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62282       };
62283     }
62284   }
62285
62286   jresult = result;
62287   return jresult;
62288 }
62289
62290
62291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62292   unsigned int jresult ;
62293   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62294   bool result;
62295
62296   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62297   {
62298     try {
62299       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62300     } catch (std::out_of_range& e) {
62301       {
62302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62303       };
62304     } catch (std::exception& e) {
62305       {
62306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62307       };
62308     } catch (Dali::DaliException e) {
62309       {
62310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62311       };
62312     } catch (...) {
62313       {
62314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62315       };
62316     }
62317   }
62318
62319   jresult = result;
62320   return jresult;
62321 }
62322
62323
62324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62325   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62326   Dali::PinchGesture *arg2 = 0 ;
62327
62328   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62329   arg2 = (Dali::PinchGesture *)jarg2;
62330   if (!arg2) {
62331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62332     return ;
62333   }
62334   {
62335     try {
62336       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62337     } catch (std::out_of_range& e) {
62338       {
62339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62340       };
62341     } catch (std::exception& e) {
62342       {
62343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62344       };
62345     } catch (Dali::DaliException e) {
62346       {
62347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62348       };
62349     } catch (...) {
62350       {
62351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62352       };
62353     }
62354   }
62355
62356 }
62357
62358
62359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62360   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62361   Dali::PinchGesture *arg2 = 0 ;
62362
62363   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62364   arg2 = (Dali::PinchGesture *)jarg2;
62365   if (!arg2) {
62366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62367     return ;
62368   }
62369   {
62370     try {
62371       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62372     } catch (std::out_of_range& e) {
62373       {
62374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62375       };
62376     } catch (std::exception& e) {
62377       {
62378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62379       };
62380     } catch (Dali::DaliException e) {
62381       {
62382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62383       };
62384     } catch (...) {
62385       {
62386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62387       };
62388     }
62389   }
62390
62391 }
62392
62393
62394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62395   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62396   Dali::PanGesture *arg2 = 0 ;
62397
62398   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62399   arg2 = (Dali::PanGesture *)jarg2;
62400   if (!arg2) {
62401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62402     return ;
62403   }
62404   {
62405     try {
62406       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62407     } catch (std::out_of_range& e) {
62408       {
62409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62410       };
62411     } catch (std::exception& e) {
62412       {
62413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62414       };
62415     } catch (Dali::DaliException e) {
62416       {
62417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62418       };
62419     } catch (...) {
62420       {
62421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62422       };
62423     }
62424   }
62425
62426 }
62427
62428
62429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62430   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62431   Dali::PanGesture *arg2 = 0 ;
62432
62433   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62434   arg2 = (Dali::PanGesture *)jarg2;
62435   if (!arg2) {
62436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62437     return ;
62438   }
62439   {
62440     try {
62441       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62442     } catch (std::out_of_range& e) {
62443       {
62444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62445       };
62446     } catch (std::exception& e) {
62447       {
62448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62449       };
62450     } catch (Dali::DaliException e) {
62451       {
62452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62453       };
62454     } catch (...) {
62455       {
62456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62457       };
62458     }
62459   }
62460
62461 }
62462
62463
62464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62465   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62466   Dali::TapGesture *arg2 = 0 ;
62467
62468   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62469   arg2 = (Dali::TapGesture *)jarg2;
62470   if (!arg2) {
62471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62472     return ;
62473   }
62474   {
62475     try {
62476       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62477     } catch (std::out_of_range& e) {
62478       {
62479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62480       };
62481     } catch (std::exception& e) {
62482       {
62483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62484       };
62485     } catch (Dali::DaliException e) {
62486       {
62487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62488       };
62489     } catch (...) {
62490       {
62491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62492       };
62493     }
62494   }
62495
62496 }
62497
62498
62499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62500   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62501   Dali::TapGesture *arg2 = 0 ;
62502
62503   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62504   arg2 = (Dali::TapGesture *)jarg2;
62505   if (!arg2) {
62506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62507     return ;
62508   }
62509   {
62510     try {
62511       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
62512     } catch (std::out_of_range& e) {
62513       {
62514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62515       };
62516     } catch (std::exception& e) {
62517       {
62518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62519       };
62520     } catch (Dali::DaliException e) {
62521       {
62522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62523       };
62524     } catch (...) {
62525       {
62526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62527       };
62528     }
62529   }
62530
62531 }
62532
62533
62534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62535   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62536   Dali::LongPressGesture *arg2 = 0 ;
62537
62538   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62539   arg2 = (Dali::LongPressGesture *)jarg2;
62540   if (!arg2) {
62541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62542     return ;
62543   }
62544   {
62545     try {
62546       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62547     } catch (std::out_of_range& e) {
62548       {
62549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62550       };
62551     } catch (std::exception& e) {
62552       {
62553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62554       };
62555     } catch (Dali::DaliException e) {
62556       {
62557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62558       };
62559     } catch (...) {
62560       {
62561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62562       };
62563     }
62564   }
62565
62566 }
62567
62568
62569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62570   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62571   Dali::LongPressGesture *arg2 = 0 ;
62572
62573   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62574   arg2 = (Dali::LongPressGesture *)jarg2;
62575   if (!arg2) {
62576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62577     return ;
62578   }
62579   {
62580     try {
62581       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62582     } catch (std::out_of_range& e) {
62583       {
62584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62585       };
62586     } catch (std::exception& e) {
62587       {
62588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62589       };
62590     } catch (Dali::DaliException e) {
62591       {
62592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62593       };
62594     } catch (...) {
62595       {
62596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62597       };
62598     }
62599   }
62600
62601 }
62602
62603
62604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62605   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62606   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62607   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62608
62609   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62610   arg2 = (Dali::SlotObserver *)jarg2;
62611   arg3 = (Dali::CallbackBase *)jarg3;
62612   {
62613     try {
62614       (arg1)->SignalConnected(arg2,arg3);
62615     } catch (std::out_of_range& e) {
62616       {
62617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62618       };
62619     } catch (std::exception& e) {
62620       {
62621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62622       };
62623     } catch (Dali::DaliException e) {
62624       {
62625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62626       };
62627     } catch (...) {
62628       {
62629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62630       };
62631     }
62632   }
62633
62634 }
62635
62636
62637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62638   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62639   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62640   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62641
62642   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62643   arg2 = (Dali::SlotObserver *)jarg2;
62644   arg3 = (Dali::CallbackBase *)jarg3;
62645   {
62646     try {
62647       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62648     } catch (std::out_of_range& e) {
62649       {
62650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62651       };
62652     } catch (std::exception& e) {
62653       {
62654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62655       };
62656     } catch (Dali::DaliException e) {
62657       {
62658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62659       };
62660     } catch (...) {
62661       {
62662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62663       };
62664     }
62665   }
62666
62667 }
62668
62669
62670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62671   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62672   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62673   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62674
62675   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62676   arg2 = (Dali::SlotObserver *)jarg2;
62677   arg3 = (Dali::CallbackBase *)jarg3;
62678   {
62679     try {
62680       (arg1)->SignalDisconnected(arg2,arg3);
62681     } catch (std::out_of_range& e) {
62682       {
62683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62684       };
62685     } catch (std::exception& e) {
62686       {
62687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62688       };
62689     } catch (Dali::DaliException e) {
62690       {
62691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62692       };
62693     } catch (...) {
62694       {
62695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62696       };
62697     }
62698   }
62699
62700 }
62701
62702
62703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62704   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62705   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62706   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62707
62708   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62709   arg2 = (Dali::SlotObserver *)jarg2;
62710   arg3 = (Dali::CallbackBase *)jarg3;
62711   {
62712     try {
62713       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62714     } catch (std::out_of_range& e) {
62715       {
62716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62717       };
62718     } catch (std::exception& e) {
62719       {
62720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62721       };
62722     } catch (Dali::DaliException e) {
62723       {
62724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62725       };
62726     } catch (...) {
62727       {
62728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62729       };
62730     }
62731   }
62732
62733 }
62734
62735 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) {
62736   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62737   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62738   if (director) {
62739     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);
62740   }
62741 }
62742
62743
62744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
62745   void * jresult ;
62746   Dali::Toolkit::Control *arg1 = 0 ;
62747   Dali::Toolkit::Internal::Control *result = 0 ;
62748
62749   arg1 = (Dali::Toolkit::Control *)jarg1;
62750   if (!arg1) {
62751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62752     return 0;
62753   }
62754   {
62755     try {
62756       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62757     } catch (std::out_of_range& e) {
62758       {
62759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62760       };
62761     } catch (std::exception& e) {
62762       {
62763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62764       };
62765     } catch (Dali::DaliException e) {
62766       {
62767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62768       };
62769     } catch (...) {
62770       {
62771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62772       };
62773     }
62774   }
62775
62776   jresult = (void *)result;
62777   return jresult;
62778 }
62779
62780
62781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
62782   int jresult ;
62783   int result;
62784
62785   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
62786   jresult = (int)result;
62787   return jresult;
62788 }
62789
62790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
62791   int jresult ;
62792   int result;
62793
62794   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
62795   jresult = (int)result;
62796   return jresult;
62797 }
62798
62799
62800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
62801   int jresult ;
62802   int result;
62803
62804   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
62805   jresult = (int)result;
62806   return jresult;
62807 }
62808
62809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
62810   int jresult ;
62811   int result;
62812
62813   result = (int)Dali::Toolkit::Control::Property::MARGIN;
62814   jresult = (int)result;
62815   return jresult;
62816 }
62817
62818
62819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
62820   int jresult ;
62821   int result;
62822
62823   result = (int)Dali::Toolkit::Control::Property::PADDING;
62824   jresult = (int)result;
62825   return jresult;
62826 }
62827
62828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
62829   int jresult ;
62830   int result;
62831
62832   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
62833   jresult = (int)result;
62834   return jresult;
62835 }
62836
62837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
62838   void * jresult ;
62839   Dali::Toolkit::Control::Property *result = 0 ;
62840
62841   {
62842     try {
62843       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
62844     } catch (std::out_of_range& e) {
62845       {
62846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62847       };
62848     } catch (std::exception& e) {
62849       {
62850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62851       };
62852     } catch (Dali::DaliException e) {
62853       {
62854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62855       };
62856     } catch (...) {
62857       {
62858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62859       };
62860     }
62861   }
62862
62863   jresult = (void *)result;
62864   return jresult;
62865 }
62866
62867
62868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
62869   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
62870
62871   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
62872   {
62873     try {
62874       delete arg1;
62875     } catch (std::out_of_range& e) {
62876       {
62877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62878       };
62879     } catch (std::exception& e) {
62880       {
62881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62882       };
62883     } catch (Dali::DaliException e) {
62884       {
62885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62886       };
62887     } catch (...) {
62888       {
62889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62890       };
62891     }
62892   }
62893
62894 }
62895
62896
62897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
62898   void * jresult ;
62899   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
62900
62901   {
62902     try {
62903       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
62904     } catch (std::out_of_range& e) {
62905       {
62906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62907       };
62908     } catch (std::exception& e) {
62909       {
62910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62911       };
62912     } catch (Dali::DaliException e) {
62913       {
62914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62915       };
62916     } catch (...) {
62917       {
62918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62919       };
62920     }
62921   }
62922
62923   jresult = (void *)result;
62924   return jresult;
62925 }
62926
62927
62928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
62929   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
62930
62931   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
62932   {
62933     try {
62934       delete arg1;
62935     } catch (std::out_of_range& e) {
62936       {
62937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62938       };
62939     } catch (std::exception& e) {
62940       {
62941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62942       };
62943     } catch (Dali::DaliException e) {
62944       {
62945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62946       };
62947     } catch (...) {
62948       {
62949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62950       };
62951     }
62952   }
62953
62954 }
62955
62956
62957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
62958   void * jresult ;
62959   Dali::Toolkit::Control result;
62960
62961   {
62962     try {
62963       result = Dali::Toolkit::Control::New();
62964     } catch (std::out_of_range& e) {
62965       {
62966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62967       };
62968     } catch (std::exception& e) {
62969       {
62970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62971       };
62972     } catch (Dali::DaliException e) {
62973       {
62974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62975       };
62976     } catch (...) {
62977       {
62978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62979       };
62980     }
62981   }
62982
62983   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62984   return jresult;
62985 }
62986
62987
62988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
62989   void * jresult ;
62990   Dali::Toolkit::Control *result = 0 ;
62991
62992   {
62993     try {
62994       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
62995     } catch (std::out_of_range& e) {
62996       {
62997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62998       };
62999     } catch (std::exception& e) {
63000       {
63001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63002       };
63003     } catch (Dali::DaliException e) {
63004       {
63005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63006       };
63007     } catch (...) {
63008       {
63009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63010       };
63011     }
63012   }
63013
63014   jresult = (void *)result;
63015   return jresult;
63016 }
63017
63018
63019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63020   void * jresult ;
63021   Dali::Toolkit::Control *arg1 = 0 ;
63022   Dali::Toolkit::Control *result = 0 ;
63023
63024   arg1 = (Dali::Toolkit::Control *)jarg1;
63025   if (!arg1) {
63026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63027     return 0;
63028   }
63029   {
63030     try {
63031       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63032     } catch (std::out_of_range& e) {
63033       {
63034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63035       };
63036     } catch (std::exception& e) {
63037       {
63038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63039       };
63040     } catch (Dali::DaliException e) {
63041       {
63042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63043       };
63044     } catch (...) {
63045       {
63046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63047       };
63048     }
63049   }
63050
63051   jresult = (void *)result;
63052   return jresult;
63053 }
63054
63055
63056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63057   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63058
63059   arg1 = (Dali::Toolkit::Control *)jarg1;
63060   {
63061     try {
63062       delete arg1;
63063     } catch (std::out_of_range& e) {
63064       {
63065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63066       };
63067     } catch (std::exception& e) {
63068       {
63069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63070       };
63071     } catch (Dali::DaliException e) {
63072       {
63073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63074       };
63075     } catch (...) {
63076       {
63077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63078       };
63079     }
63080   }
63081
63082 }
63083
63084
63085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63086   void * jresult ;
63087   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63088   Dali::Toolkit::Control *arg2 = 0 ;
63089   Dali::Toolkit::Control *result = 0 ;
63090
63091   arg1 = (Dali::Toolkit::Control *)jarg1;
63092   arg2 = (Dali::Toolkit::Control *)jarg2;
63093   if (!arg2) {
63094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63095     return 0;
63096   }
63097   {
63098     try {
63099       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63100     } catch (std::out_of_range& e) {
63101       {
63102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63103       };
63104     } catch (std::exception& e) {
63105       {
63106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63107       };
63108     } catch (Dali::DaliException e) {
63109       {
63110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63111       };
63112     } catch (...) {
63113       {
63114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63115       };
63116     }
63117   }
63118
63119   jresult = (void *)result;
63120   return jresult;
63121 }
63122
63123
63124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63125   void * jresult ;
63126   Dali::BaseHandle arg1 ;
63127   Dali::BaseHandle *argp1 ;
63128   Dali::Toolkit::Control result;
63129
63130   argp1 = (Dali::BaseHandle *)jarg1;
63131   if (!argp1) {
63132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63133     return 0;
63134   }
63135   arg1 = *argp1;
63136   {
63137     try {
63138       result = Dali::Toolkit::Control::DownCast(arg1);
63139     } catch (std::out_of_range& e) {
63140       {
63141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63142       };
63143     } catch (std::exception& e) {
63144       {
63145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63146       };
63147     } catch (Dali::DaliException e) {
63148       {
63149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63150       };
63151     } catch (...) {
63152       {
63153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63154       };
63155     }
63156   }
63157
63158   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63159   return jresult;
63160 }
63161
63162
63163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63164   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63165
63166   arg1 = (Dali::Toolkit::Control *)jarg1;
63167   {
63168     try {
63169       (arg1)->SetKeyInputFocus();
63170     } catch (std::out_of_range& e) {
63171       {
63172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63173       };
63174     } catch (std::exception& e) {
63175       {
63176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63177       };
63178     } catch (Dali::DaliException e) {
63179       {
63180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63181       };
63182     } catch (...) {
63183       {
63184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63185       };
63186     }
63187   }
63188
63189 }
63190
63191
63192 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63193   unsigned int jresult ;
63194   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63195   bool result;
63196
63197   arg1 = (Dali::Toolkit::Control *)jarg1;
63198   {
63199     try {
63200       result = (bool)(arg1)->HasKeyInputFocus();
63201     } catch (std::out_of_range& e) {
63202       {
63203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63204       };
63205     } catch (std::exception& e) {
63206       {
63207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63208       };
63209     } catch (Dali::DaliException e) {
63210       {
63211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63212       };
63213     } catch (...) {
63214       {
63215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63216       };
63217     }
63218   }
63219
63220   jresult = result;
63221   return jresult;
63222 }
63223
63224
63225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63226   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63227
63228   arg1 = (Dali::Toolkit::Control *)jarg1;
63229   {
63230     try {
63231       (arg1)->ClearKeyInputFocus();
63232     } catch (std::out_of_range& e) {
63233       {
63234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63235       };
63236     } catch (std::exception& e) {
63237       {
63238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63239       };
63240     } catch (Dali::DaliException e) {
63241       {
63242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63243       };
63244     } catch (...) {
63245       {
63246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63247       };
63248     }
63249   }
63250
63251 }
63252
63253
63254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63255   void * jresult ;
63256   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63257   Dali::PinchGestureDetector result;
63258
63259   arg1 = (Dali::Toolkit::Control *)jarg1;
63260   {
63261     try {
63262       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63263     } catch (std::out_of_range& e) {
63264       {
63265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63266       };
63267     } catch (std::exception& e) {
63268       {
63269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63270       };
63271     } catch (Dali::DaliException e) {
63272       {
63273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63274       };
63275     } catch (...) {
63276       {
63277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63278       };
63279     }
63280   }
63281
63282   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63283   return jresult;
63284 }
63285
63286
63287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63288   void * jresult ;
63289   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63290   Dali::PanGestureDetector result;
63291
63292   arg1 = (Dali::Toolkit::Control *)jarg1;
63293   {
63294     try {
63295       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63296     } catch (std::out_of_range& e) {
63297       {
63298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63299       };
63300     } catch (std::exception& e) {
63301       {
63302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63303       };
63304     } catch (Dali::DaliException e) {
63305       {
63306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63307       };
63308     } catch (...) {
63309       {
63310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63311       };
63312     }
63313   }
63314
63315   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63316   return jresult;
63317 }
63318
63319
63320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63321   void * jresult ;
63322   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63323   Dali::TapGestureDetector result;
63324
63325   arg1 = (Dali::Toolkit::Control *)jarg1;
63326   {
63327     try {
63328       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63329     } catch (std::out_of_range& e) {
63330       {
63331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63332       };
63333     } catch (std::exception& e) {
63334       {
63335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63336       };
63337     } catch (Dali::DaliException e) {
63338       {
63339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63340       };
63341     } catch (...) {
63342       {
63343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63344       };
63345     }
63346   }
63347
63348   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63349   return jresult;
63350 }
63351
63352
63353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63354   void * jresult ;
63355   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63356   Dali::LongPressGestureDetector result;
63357
63358   arg1 = (Dali::Toolkit::Control *)jarg1;
63359   {
63360     try {
63361       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63362     } catch (std::out_of_range& e) {
63363       {
63364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63365       };
63366     } catch (std::exception& e) {
63367       {
63368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63369       };
63370     } catch (Dali::DaliException e) {
63371       {
63372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63373       };
63374     } catch (...) {
63375       {
63376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63377       };
63378     }
63379   }
63380
63381   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63382   return jresult;
63383 }
63384
63385
63386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63387   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63388   std::string *arg2 = 0 ;
63389
63390   arg1 = (Dali::Toolkit::Control *)jarg1;
63391   if (!jarg2) {
63392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63393     return ;
63394   }
63395   std::string arg2_str(jarg2);
63396   arg2 = &arg2_str;
63397   {
63398     try {
63399       (arg1)->SetStyleName((std::string const &)*arg2);
63400     } catch (std::out_of_range& e) {
63401       {
63402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63403       };
63404     } catch (std::exception& e) {
63405       {
63406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63407       };
63408     } catch (Dali::DaliException e) {
63409       {
63410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63411       };
63412     } catch (...) {
63413       {
63414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63415       };
63416     }
63417   }
63418
63419
63420   //argout typemap for const std::string&
63421
63422 }
63423
63424
63425 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63426   char * jresult ;
63427   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63428   std::string *result = 0 ;
63429
63430   arg1 = (Dali::Toolkit::Control *)jarg1;
63431   {
63432     try {
63433       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63434     } catch (std::out_of_range& e) {
63435       {
63436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63437       };
63438     } catch (std::exception& e) {
63439       {
63440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63441       };
63442     } catch (Dali::DaliException e) {
63443       {
63444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63445       };
63446     } catch (...) {
63447       {
63448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63449       };
63450     }
63451   }
63452
63453   jresult = SWIG_csharp_string_callback(result->c_str());
63454   return jresult;
63455 }
63456
63457
63458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63459   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63460   Dali::Vector4 *arg2 = 0 ;
63461
63462   arg1 = (Dali::Toolkit::Control *)jarg1;
63463   arg2 = (Dali::Vector4 *)jarg2;
63464   if (!arg2) {
63465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63466     return ;
63467   }
63468   {
63469     try {
63470       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63471     } catch (std::out_of_range& e) {
63472       {
63473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63474       };
63475     } catch (std::exception& e) {
63476       {
63477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63478       };
63479     } catch (Dali::DaliException e) {
63480       {
63481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63482       };
63483     } catch (...) {
63484       {
63485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63486       };
63487     }
63488   }
63489
63490 }
63491
63492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
63493   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63494
63495   arg1 = (Dali::Toolkit::Control *)jarg1;
63496   {
63497     try {
63498       (arg1)->ClearBackground();
63499     } catch (std::out_of_range& e) {
63500       {
63501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63502       };
63503     } catch (std::exception& e) {
63504       {
63505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63506       };
63507     } catch (Dali::DaliException e) {
63508       {
63509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63510       };
63511     } catch (...) {
63512       {
63513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63514       };
63515     }
63516   }
63517
63518 }
63519
63520
63521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
63522   void * jresult ;
63523   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63524   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63525
63526   arg1 = (Dali::Toolkit::Control *)jarg1;
63527   {
63528     try {
63529       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63530     } catch (std::out_of_range& e) {
63531       {
63532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63533       };
63534     } catch (std::exception& e) {
63535       {
63536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63537       };
63538     } catch (Dali::DaliException e) {
63539       {
63540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63541       };
63542     } catch (...) {
63543       {
63544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63545       };
63546     }
63547   }
63548
63549   jresult = (void *)result;
63550   return jresult;
63551 }
63552
63553
63554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
63555   void * jresult ;
63556   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63557   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63558
63559   arg1 = (Dali::Toolkit::Control *)jarg1;
63560   {
63561     try {
63562       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63563     } catch (std::out_of_range& e) {
63564       {
63565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63566       };
63567     } catch (std::exception& e) {
63568       {
63569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63570       };
63571     } catch (Dali::DaliException e) {
63572       {
63573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63574       };
63575     } catch (...) {
63576       {
63577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63578       };
63579     }
63580   }
63581
63582   jresult = (void *)result;
63583   return jresult;
63584 }
63585
63586
63587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
63588   void * jresult ;
63589   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63590   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63591
63592   arg1 = (Dali::Toolkit::Control *)jarg1;
63593   {
63594     try {
63595       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63596     } catch (std::out_of_range& e) {
63597       {
63598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63599       };
63600     } catch (std::exception& e) {
63601       {
63602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63603       };
63604     } catch (Dali::DaliException e) {
63605       {
63606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63607       };
63608     } catch (...) {
63609       {
63610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63611       };
63612     }
63613   }
63614
63615   jresult = (void *)result;
63616   return jresult;
63617 }
63618
63619
63620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
63621   void * jresult ;
63622   Dali::Toolkit::Internal::Control *arg1 = 0 ;
63623   Dali::Toolkit::Control *result = 0 ;
63624
63625   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63626   if (!arg1) {
63627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63628     return 0;
63629   }
63630   {
63631     try {
63632       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63633     } catch (std::out_of_range& e) {
63634       {
63635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63636       };
63637     } catch (std::exception& e) {
63638       {
63639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63640       };
63641     } catch (Dali::DaliException e) {
63642       {
63643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63644       };
63645     } catch (...) {
63646       {
63647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63648       };
63649     }
63650   }
63651
63652   jresult = (void *)result;
63653   return jresult;
63654 }
63655
63656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
63657 {
63658   int jresult;
63659   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63660   arg1 = (Dali::Toolkit::Control *)jarg1;
63661
63662   if (!arg1) {
63663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63664     return 0;
63665   }
63666
63667   Dali::Property::Index arg2 = 0 ;
63668   arg2 = (Dali::Property::Index)jarg2;
63669
63670   Toolkit::Visual::ResourceStatus result;
63671   {
63672     try {
63673       result = arg1->GetVisualResourceStatus(arg2);
63674     } catch (std::out_of_range& e) {
63675       {
63676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63677       };
63678     } catch (std::exception& e) {
63679       {
63680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63681       };
63682     } catch (...) {
63683       {
63684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63685       };
63686     }
63687   }
63688   jresult = (int)(result);
63689   return jresult;
63690 }
63691
63692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
63693 {
63694   void * jresult;
63695   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63696   arg1 = (Dali::Toolkit::Control *)jarg1;
63697
63698   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
63699
63700   Dali::Toolkit::TransitionData *arg2 = 0 ;
63701   Dali::Animation result;
63702
63703   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
63704   if (!arg2) {
63705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
63706     return 0;
63707   }
63708   {
63709     try {
63710       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
63711     } catch (std::out_of_range& e) {
63712       {
63713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63714       };
63715     } catch (std::exception& e) {
63716       {
63717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63718       };
63719     } catch (Dali::DaliException e) {
63720       {
63721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63722       };
63723     } catch (...) {
63724       {
63725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63726       };
63727     }
63728   }
63729
63730   jresult = new Dali::Animation((const Dali::Animation &)result);
63731   return jresult;
63732 }
63733
63734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
63735 {
63736   Dali::Toolkit::Control arg1;
63737   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
63738
63739   if (!argp1) {
63740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63741   }
63742   arg1 = *argp1;
63743
63744   Dali::Property::Index arg2 = 0 ;
63745   arg2 = (Dali::Property::Index)jarg2;
63746
63747   Dali::Property::Index arg3 = 0 ;
63748   arg3 = (Dali::Property::Index)jarg3;
63749
63750   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
63751
63752   {
63753     try {
63754       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
63755     } catch (std::out_of_range& e) {
63756       {
63757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63758       };
63759     } catch (std::exception& e) {
63760       {
63761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63762       };
63763     } catch (...) {
63764       {
63765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63766       };
63767     }
63768   }
63769
63770
63771 }
63772
63773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
63774   void * jresult ;
63775   Dali::Toolkit::Control *arg1 = 0 ;
63776   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
63777
63778   arg1 = (Dali::Toolkit::Control *)jarg1;
63779   if (!arg1) {
63780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63781     return 0;
63782   }
63783   {
63784     try {
63785       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
63786     } catch (std::out_of_range& e) {
63787       {
63788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63789       };
63790     } catch (std::exception& e) {
63791       {
63792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63793       };
63794     } catch (Dali::DaliException e) {
63795       {
63796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63797       };
63798     } catch (...) {
63799       {
63800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63801       };
63802     }
63803   }
63804
63805   jresult = (void *)result;
63806   return jresult;
63807 }
63808
63809
63810 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
63811   unsigned int jresult ;
63812   Dali::Toolkit::Control *arg1 = 0 ;
63813   bool result;
63814
63815   arg1 = (Dali::Toolkit::Control *)jarg1;
63816   if (!arg1) {
63817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63818     return 0;
63819   }
63820   {
63821     try {
63822       result = (bool)arg1->IsResourceReady();
63823     } catch (std::out_of_range& e) {
63824       {
63825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63826       };
63827     } catch (std::exception& e) {
63828       {
63829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63830       };
63831     } catch (Dali::DaliException e) {
63832       {
63833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63834       };
63835     } catch (...) {
63836       {
63837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63838       };
63839     }
63840   }
63841
63842   jresult = result;
63843   return jresult;
63844 }
63845
63846
63847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
63848   void * jresult ;
63849   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
63850
63851   {
63852     try {
63853       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
63854     } catch (std::out_of_range& e) {
63855       {
63856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63857       };
63858     } catch (std::exception& e) {
63859       {
63860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63861       };
63862     } catch (Dali::DaliException e) {
63863       {
63864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63865       };
63866     } catch (...) {
63867       {
63868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63869       };
63870     }
63871   }
63872
63873   jresult = (void *)result;
63874   return jresult;
63875 }
63876
63877
63878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
63879   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63880
63881   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63882   {
63883     try {
63884       delete arg1;
63885     } catch (std::out_of_range& e) {
63886       {
63887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63888       };
63889     } catch (std::exception& e) {
63890       {
63891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63892       };
63893     } catch (Dali::DaliException e) {
63894       {
63895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63896       };
63897     } catch (...) {
63898       {
63899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63900       };
63901     }
63902   }
63903
63904 }
63905
63906
63907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
63908   void * jresult ;
63909   Dali::Toolkit::KeyInputFocusManager result;
63910
63911   {
63912     try {
63913       result = Dali::Toolkit::KeyInputFocusManager::Get();
63914     } catch (std::out_of_range& e) {
63915       {
63916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63917       };
63918     } catch (std::exception& e) {
63919       {
63920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63921       };
63922     } catch (Dali::DaliException e) {
63923       {
63924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63925       };
63926     } catch (...) {
63927       {
63928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63929       };
63930     }
63931   }
63932
63933   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
63934   return jresult;
63935 }
63936
63937
63938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
63939   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63940   Dali::Toolkit::Control arg2 ;
63941   Dali::Toolkit::Control *argp2 ;
63942
63943   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63944   argp2 = (Dali::Toolkit::Control *)jarg2;
63945   if (!argp2) {
63946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63947     return ;
63948   }
63949   arg2 = *argp2;
63950   {
63951     try {
63952       (arg1)->SetFocus(arg2);
63953     } catch (std::out_of_range& e) {
63954       {
63955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63956       };
63957     } catch (std::exception& e) {
63958       {
63959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63960       };
63961     } catch (Dali::DaliException e) {
63962       {
63963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63964       };
63965     } catch (...) {
63966       {
63967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63968       };
63969     }
63970   }
63971
63972 }
63973
63974
63975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
63976   void * jresult ;
63977   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63978   Dali::Toolkit::Control result;
63979
63980   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63981   {
63982     try {
63983       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
63984     } catch (std::out_of_range& e) {
63985       {
63986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63987       };
63988     } catch (std::exception& e) {
63989       {
63990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63991       };
63992     } catch (Dali::DaliException e) {
63993       {
63994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63995       };
63996     } catch (...) {
63997       {
63998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63999       };
64000     }
64001   }
64002
64003   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64004   return jresult;
64005 }
64006
64007
64008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64009   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64010   Dali::Toolkit::Control arg2 ;
64011   Dali::Toolkit::Control *argp2 ;
64012
64013   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64014   argp2 = (Dali::Toolkit::Control *)jarg2;
64015   if (!argp2) {
64016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64017     return ;
64018   }
64019   arg2 = *argp2;
64020   {
64021     try {
64022       (arg1)->RemoveFocus(arg2);
64023     } catch (std::out_of_range& e) {
64024       {
64025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64026       };
64027     } catch (std::exception& e) {
64028       {
64029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64030       };
64031     } catch (Dali::DaliException e) {
64032       {
64033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64034       };
64035     } catch (...) {
64036       {
64037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64038       };
64039     }
64040   }
64041
64042 }
64043
64044
64045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64046   void * jresult ;
64047   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64048   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64049
64050   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64051   {
64052     try {
64053       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64054     } catch (std::out_of_range& e) {
64055       {
64056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64057       };
64058     } catch (std::exception& e) {
64059       {
64060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64061       };
64062     } catch (Dali::DaliException e) {
64063       {
64064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64065       };
64066     } catch (...) {
64067       {
64068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64069       };
64070     }
64071   }
64072
64073   jresult = (void *)result;
64074   return jresult;
64075 }
64076
64077
64078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
64079   void * jresult ;
64080   Dali::Toolkit::Alignment::Padding *result = 0 ;
64081
64082   {
64083     try {
64084       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64085     } catch (std::out_of_range& e) {
64086       {
64087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64088       };
64089     } catch (std::exception& e) {
64090       {
64091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64092       };
64093     } catch (Dali::DaliException e) {
64094       {
64095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64096       };
64097     } catch (...) {
64098       {
64099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64100       };
64101     }
64102   }
64103
64104   jresult = (void *)result;
64105   return jresult;
64106 }
64107
64108
64109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64110   void * jresult ;
64111   float arg1 ;
64112   float arg2 ;
64113   float arg3 ;
64114   float arg4 ;
64115   Dali::Toolkit::Alignment::Padding *result = 0 ;
64116
64117   arg1 = (float)jarg1;
64118   arg2 = (float)jarg2;
64119   arg3 = (float)jarg3;
64120   arg4 = (float)jarg4;
64121   {
64122     try {
64123       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64124     } catch (std::out_of_range& e) {
64125       {
64126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64127       };
64128     } catch (std::exception& e) {
64129       {
64130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64131       };
64132     } catch (Dali::DaliException e) {
64133       {
64134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64135       };
64136     } catch (...) {
64137       {
64138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64139       };
64140     }
64141   }
64142
64143   jresult = (void *)result;
64144   return jresult;
64145 }
64146
64147
64148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64149   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64150   float arg2 ;
64151
64152   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64153   arg2 = (float)jarg2;
64154   if (arg1) (arg1)->left = arg2;
64155 }
64156
64157
64158 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
64159   float jresult ;
64160   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64161   float result;
64162
64163   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64164   result = (float) ((arg1)->left);
64165   jresult = result;
64166   return jresult;
64167 }
64168
64169
64170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64171   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64172   float arg2 ;
64173
64174   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64175   arg2 = (float)jarg2;
64176   if (arg1) (arg1)->right = arg2;
64177 }
64178
64179
64180 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
64181   float jresult ;
64182   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64183   float result;
64184
64185   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64186   result = (float) ((arg1)->right);
64187   jresult = result;
64188   return jresult;
64189 }
64190
64191
64192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64193   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64194   float arg2 ;
64195
64196   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64197   arg2 = (float)jarg2;
64198   if (arg1) (arg1)->top = arg2;
64199 }
64200
64201
64202 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
64203   float jresult ;
64204   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64205   float result;
64206
64207   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64208   result = (float) ((arg1)->top);
64209   jresult = result;
64210   return jresult;
64211 }
64212
64213
64214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64215   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64216   float arg2 ;
64217
64218   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64219   arg2 = (float)jarg2;
64220   if (arg1) (arg1)->bottom = arg2;
64221 }
64222
64223
64224 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64225   float jresult ;
64226   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64227   float result;
64228
64229   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64230   result = (float) ((arg1)->bottom);
64231   jresult = result;
64232   return jresult;
64233 }
64234
64235
64236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64237   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64238
64239   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64240   {
64241     try {
64242       delete arg1;
64243     } catch (std::out_of_range& e) {
64244       {
64245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64246       };
64247     } catch (std::exception& e) {
64248       {
64249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64250       };
64251     } catch (Dali::DaliException e) {
64252       {
64253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64254       };
64255     } catch (...) {
64256       {
64257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64258       };
64259     }
64260   }
64261
64262 }
64263
64264
64265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64266   void * jresult ;
64267   Dali::Toolkit::Alignment *result = 0 ;
64268
64269   {
64270     try {
64271       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64272     } catch (std::out_of_range& e) {
64273       {
64274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64275       };
64276     } catch (std::exception& e) {
64277       {
64278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64279       };
64280     } catch (Dali::DaliException e) {
64281       {
64282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64283       };
64284     } catch (...) {
64285       {
64286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64287       };
64288     }
64289   }
64290
64291   jresult = (void *)result;
64292   return jresult;
64293 }
64294
64295
64296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64297   void * jresult ;
64298   Dali::Toolkit::Alignment::Type arg1 ;
64299   Dali::Toolkit::Alignment::Type arg2 ;
64300   Dali::Toolkit::Alignment result;
64301
64302   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64303   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64304   {
64305     try {
64306       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64307     } catch (std::out_of_range& e) {
64308       {
64309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64310       };
64311     } catch (std::exception& e) {
64312       {
64313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64314       };
64315     } catch (Dali::DaliException e) {
64316       {
64317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64318       };
64319     } catch (...) {
64320       {
64321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64322       };
64323     }
64324   }
64325
64326   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64327   return jresult;
64328 }
64329
64330
64331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64332   void * jresult ;
64333   Dali::Toolkit::Alignment::Type arg1 ;
64334   Dali::Toolkit::Alignment result;
64335
64336   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64337   {
64338     try {
64339       result = Dali::Toolkit::Alignment::New(arg1);
64340     } catch (std::out_of_range& e) {
64341       {
64342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64343       };
64344     } catch (std::exception& e) {
64345       {
64346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64347       };
64348     } catch (Dali::DaliException e) {
64349       {
64350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64351       };
64352     } catch (...) {
64353       {
64354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64355       };
64356     }
64357   }
64358
64359   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64360   return jresult;
64361 }
64362
64363
64364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64365   void * jresult ;
64366   Dali::Toolkit::Alignment result;
64367
64368   {
64369     try {
64370       result = Dali::Toolkit::Alignment::New();
64371     } catch (std::out_of_range& e) {
64372       {
64373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64374       };
64375     } catch (std::exception& e) {
64376       {
64377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64378       };
64379     } catch (Dali::DaliException e) {
64380       {
64381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64382       };
64383     } catch (...) {
64384       {
64385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64386       };
64387     }
64388   }
64389
64390   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64391   return jresult;
64392 }
64393
64394
64395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64396   void * jresult ;
64397   Dali::Toolkit::Alignment *arg1 = 0 ;
64398   Dali::Toolkit::Alignment *result = 0 ;
64399
64400   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64401   if (!arg1) {
64402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64403     return 0;
64404   }
64405   {
64406     try {
64407       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64408     } catch (std::out_of_range& e) {
64409       {
64410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64411       };
64412     } catch (std::exception& e) {
64413       {
64414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64415       };
64416     } catch (Dali::DaliException e) {
64417       {
64418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64419       };
64420     } catch (...) {
64421       {
64422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64423       };
64424     }
64425   }
64426
64427   jresult = (void *)result;
64428   return jresult;
64429 }
64430
64431
64432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64433   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64434
64435   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64436   {
64437     try {
64438       delete arg1;
64439     } catch (std::out_of_range& e) {
64440       {
64441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64442       };
64443     } catch (std::exception& e) {
64444       {
64445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64446       };
64447     } catch (Dali::DaliException e) {
64448       {
64449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64450       };
64451     } catch (...) {
64452       {
64453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64454       };
64455     }
64456   }
64457
64458 }
64459
64460
64461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64462   void * jresult ;
64463   Dali::BaseHandle arg1 ;
64464   Dali::BaseHandle *argp1 ;
64465   Dali::Toolkit::Alignment result;
64466
64467   argp1 = (Dali::BaseHandle *)jarg1;
64468   if (!argp1) {
64469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64470     return 0;
64471   }
64472   arg1 = *argp1;
64473   {
64474     try {
64475       result = Dali::Toolkit::Alignment::DownCast(arg1);
64476     } catch (std::out_of_range& e) {
64477       {
64478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64479       };
64480     } catch (std::exception& e) {
64481       {
64482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64483       };
64484     } catch (Dali::DaliException e) {
64485       {
64486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64487       };
64488     } catch (...) {
64489       {
64490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64491       };
64492     }
64493   }
64494
64495   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64496   return jresult;
64497 }
64498
64499
64500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64501   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64502   Dali::Toolkit::Alignment::Type arg2 ;
64503
64504   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64505   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64506   {
64507     try {
64508       (arg1)->SetAlignmentType(arg2);
64509     } catch (std::out_of_range& e) {
64510       {
64511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64512       };
64513     } catch (std::exception& e) {
64514       {
64515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64516       };
64517     } catch (Dali::DaliException e) {
64518       {
64519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64520       };
64521     } catch (...) {
64522       {
64523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64524       };
64525     }
64526   }
64527
64528 }
64529
64530
64531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64532   int jresult ;
64533   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64534   Dali::Toolkit::Alignment::Type result;
64535
64536   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64537   {
64538     try {
64539       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64540     } catch (std::out_of_range& e) {
64541       {
64542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64543       };
64544     } catch (std::exception& e) {
64545       {
64546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64547       };
64548     } catch (Dali::DaliException e) {
64549       {
64550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64551       };
64552     } catch (...) {
64553       {
64554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64555       };
64556     }
64557   }
64558
64559   jresult = (int)result;
64560   return jresult;
64561 }
64562
64563
64564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64565   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64566   Dali::Toolkit::Alignment::Scaling arg2 ;
64567
64568   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64569   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64570   {
64571     try {
64572       (arg1)->SetScaling(arg2);
64573     } catch (std::out_of_range& e) {
64574       {
64575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64576       };
64577     } catch (std::exception& e) {
64578       {
64579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64580       };
64581     } catch (Dali::DaliException e) {
64582       {
64583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64584       };
64585     } catch (...) {
64586       {
64587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64588       };
64589     }
64590   }
64591
64592 }
64593
64594
64595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64596   int jresult ;
64597   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64598   Dali::Toolkit::Alignment::Scaling result;
64599
64600   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64601   {
64602     try {
64603       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64604     } catch (std::out_of_range& e) {
64605       {
64606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64607       };
64608     } catch (std::exception& e) {
64609       {
64610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64611       };
64612     } catch (Dali::DaliException e) {
64613       {
64614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64615       };
64616     } catch (...) {
64617       {
64618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64619       };
64620     }
64621   }
64622
64623   jresult = (int)result;
64624   return jresult;
64625 }
64626
64627
64628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64629   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64630   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64631
64632   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64633   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64634   if (!arg2) {
64635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64636     return ;
64637   }
64638   {
64639     try {
64640       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64641     } catch (std::out_of_range& e) {
64642       {
64643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64644       };
64645     } catch (std::exception& e) {
64646       {
64647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64648       };
64649     } catch (Dali::DaliException e) {
64650       {
64651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64652       };
64653     } catch (...) {
64654       {
64655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64656       };
64657     }
64658   }
64659
64660 }
64661
64662
64663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
64664   void * jresult ;
64665   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64666   Dali::Toolkit::Alignment::Padding *result = 0 ;
64667
64668   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64669   {
64670     try {
64671       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64672     } catch (std::out_of_range& e) {
64673       {
64674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64675       };
64676     } catch (std::exception& e) {
64677       {
64678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64679       };
64680     } catch (Dali::DaliException e) {
64681       {
64682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64683       };
64684     } catch (...) {
64685       {
64686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64687       };
64688     }
64689   }
64690
64691   jresult = (void *)result;
64692   return jresult;
64693 }
64694
64695
64696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
64697   void * jresult ;
64698   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64699   Dali::Toolkit::Alignment *arg2 = 0 ;
64700   Dali::Toolkit::Alignment *result = 0 ;
64701
64702   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64703   arg2 = (Dali::Toolkit::Alignment *)jarg2;
64704   if (!arg2) {
64705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64706     return 0;
64707   }
64708   {
64709     try {
64710       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
64711     } catch (std::out_of_range& e) {
64712       {
64713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64714       };
64715     } catch (std::exception& e) {
64716       {
64717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64718       };
64719     } catch (Dali::DaliException e) {
64720       {
64721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64722       };
64723     } catch (...) {
64724       {
64725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64726       };
64727     }
64728   }
64729
64730   jresult = (void *)result;
64731   return jresult;
64732 }
64733
64734
64735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
64736   int jresult ;
64737   int result;
64738
64739   result = (int)Dali::Toolkit::Button::Property::DISABLED;
64740   jresult = (int)result;
64741   return jresult;
64742 }
64743
64744
64745 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
64746   int jresult ;
64747   int result;
64748
64749   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
64750   jresult = (int)result;
64751   return jresult;
64752 }
64753
64754
64755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
64756   int jresult ;
64757   int result;
64758
64759   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
64760   jresult = (int)result;
64761   return jresult;
64762 }
64763
64764
64765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
64766   int jresult ;
64767   int result;
64768
64769   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
64770   jresult = (int)result;
64771   return jresult;
64772 }
64773
64774
64775 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
64776   int jresult ;
64777   int result;
64778
64779   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
64780   jresult = (int)result;
64781   return jresult;
64782 }
64783
64784
64785 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
64786   int jresult ;
64787   int result;
64788
64789   result = (int)Dali::Toolkit::Button::Property::SELECTED;
64790   jresult = (int)result;
64791   return jresult;
64792 }
64793
64794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
64795   int jresult ;
64796   int result;
64797
64798   result = (int)Dali::Toolkit::Button::Property::LABEL;
64799   jresult = (int)result;
64800   return jresult;
64801 }
64802
64803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
64804   void * jresult ;
64805   Dali::Toolkit::Button::Property *result = 0 ;
64806
64807   {
64808     try {
64809       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
64810     } catch (std::out_of_range& e) {
64811       {
64812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64813       };
64814     } catch (std::exception& e) {
64815       {
64816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64817       };
64818     } catch (Dali::DaliException e) {
64819       {
64820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64821       };
64822     } catch (...) {
64823       {
64824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64825       };
64826     }
64827   }
64828
64829   jresult = (void *)result;
64830   return jresult;
64831 }
64832
64833
64834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
64835   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
64836
64837   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
64838   {
64839     try {
64840       delete arg1;
64841     } catch (std::out_of_range& e) {
64842       {
64843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64844       };
64845     } catch (std::exception& e) {
64846       {
64847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64848       };
64849     } catch (Dali::DaliException e) {
64850       {
64851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64852       };
64853     } catch (...) {
64854       {
64855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64856       };
64857     }
64858   }
64859
64860 }
64861
64862
64863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
64864   void * jresult ;
64865   Dali::Toolkit::Button *result = 0 ;
64866
64867   {
64868     try {
64869       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
64870     } catch (std::out_of_range& e) {
64871       {
64872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64873       };
64874     } catch (std::exception& e) {
64875       {
64876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64877       };
64878     } catch (Dali::DaliException e) {
64879       {
64880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64881       };
64882     } catch (...) {
64883       {
64884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64885       };
64886     }
64887   }
64888
64889   jresult = (void *)result;
64890   return jresult;
64891 }
64892
64893
64894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
64895   void * jresult ;
64896   Dali::Toolkit::Button *arg1 = 0 ;
64897   Dali::Toolkit::Button *result = 0 ;
64898
64899   arg1 = (Dali::Toolkit::Button *)jarg1;
64900   if (!arg1) {
64901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64902     return 0;
64903   }
64904   {
64905     try {
64906       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
64907     } catch (std::out_of_range& e) {
64908       {
64909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64910       };
64911     } catch (std::exception& e) {
64912       {
64913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64914       };
64915     } catch (Dali::DaliException e) {
64916       {
64917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64918       };
64919     } catch (...) {
64920       {
64921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64922       };
64923     }
64924   }
64925
64926   jresult = (void *)result;
64927   return jresult;
64928 }
64929
64930
64931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
64932   void * jresult ;
64933   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64934   Dali::Toolkit::Button *arg2 = 0 ;
64935   Dali::Toolkit::Button *result = 0 ;
64936
64937   arg1 = (Dali::Toolkit::Button *)jarg1;
64938   arg2 = (Dali::Toolkit::Button *)jarg2;
64939   if (!arg2) {
64940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64941     return 0;
64942   }
64943   {
64944     try {
64945       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
64946     } catch (std::out_of_range& e) {
64947       {
64948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64949       };
64950     } catch (std::exception& e) {
64951       {
64952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64953       };
64954     } catch (Dali::DaliException e) {
64955       {
64956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64957       };
64958     } catch (...) {
64959       {
64960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64961       };
64962     }
64963   }
64964
64965   jresult = (void *)result;
64966   return jresult;
64967 }
64968
64969
64970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
64971   void * jresult ;
64972   Dali::BaseHandle arg1 ;
64973   Dali::BaseHandle *argp1 ;
64974   Dali::Toolkit::Button result;
64975
64976   argp1 = (Dali::BaseHandle *)jarg1;
64977   if (!argp1) {
64978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64979     return 0;
64980   }
64981   arg1 = *argp1;
64982   {
64983     try {
64984       result = Dali::Toolkit::Button::DownCast(arg1);
64985     } catch (std::out_of_range& e) {
64986       {
64987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64988       };
64989     } catch (std::exception& e) {
64990       {
64991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64992       };
64993     } catch (Dali::DaliException e) {
64994       {
64995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64996       };
64997     } catch (...) {
64998       {
64999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65000       };
65001     }
65002   }
65003
65004   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65005   return jresult;
65006 }
65007
65008
65009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65010   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65011
65012   arg1 = (Dali::Toolkit::Button *)jarg1;
65013   {
65014     try {
65015       delete arg1;
65016     } catch (std::out_of_range& e) {
65017       {
65018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65019       };
65020     } catch (std::exception& e) {
65021       {
65022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65023       };
65024     } catch (Dali::DaliException e) {
65025       {
65026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65027       };
65028     } catch (...) {
65029       {
65030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65031       };
65032     }
65033   }
65034
65035 }
65036
65037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65038   void * jresult ;
65039   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65040   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65041
65042   arg1 = (Dali::Toolkit::Button *)jarg1;
65043   {
65044     try {
65045       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65046     } catch (std::out_of_range& e) {
65047       {
65048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65049       };
65050     } catch (std::exception& e) {
65051       {
65052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65053       };
65054     } catch (Dali::DaliException e) {
65055       {
65056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65057       };
65058     } catch (...) {
65059       {
65060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65061       };
65062     }
65063   }
65064
65065   jresult = (void *)result;
65066   return jresult;
65067 }
65068
65069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65070   void * jresult ;
65071   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65072   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65073
65074   arg1 = (Dali::Toolkit::Button *)jarg1;
65075   {
65076     try {
65077       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65078     } catch (std::out_of_range& e) {
65079       {
65080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65081       };
65082     } catch (std::exception& e) {
65083       {
65084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65085       };
65086     } catch (Dali::DaliException e) {
65087       {
65088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65089       };
65090     } catch (...) {
65091       {
65092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65093       };
65094     }
65095   }
65096
65097   jresult = (void *)result;
65098   return jresult;
65099 }
65100
65101
65102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65103   void * jresult ;
65104   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65105   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65106
65107   arg1 = (Dali::Toolkit::Button *)jarg1;
65108   {
65109     try {
65110       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65111     } catch (std::out_of_range& e) {
65112       {
65113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65114       };
65115     } catch (std::exception& e) {
65116       {
65117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65118       };
65119     } catch (Dali::DaliException e) {
65120       {
65121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65122       };
65123     } catch (...) {
65124       {
65125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65126       };
65127     }
65128   }
65129
65130   jresult = (void *)result;
65131   return jresult;
65132 }
65133
65134
65135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65136   void * jresult ;
65137   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65138   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65139
65140   arg1 = (Dali::Toolkit::Button *)jarg1;
65141   {
65142     try {
65143       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65144     } catch (std::out_of_range& e) {
65145       {
65146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65147       };
65148     } catch (std::exception& e) {
65149       {
65150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65151       };
65152     } catch (Dali::DaliException e) {
65153       {
65154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65155       };
65156     } catch (...) {
65157       {
65158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65159       };
65160     }
65161   }
65162
65163   jresult = (void *)result;
65164   return jresult;
65165 }
65166
65167
65168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65169   void * jresult ;
65170   Dali::Toolkit::CheckBoxButton *result = 0 ;
65171
65172   {
65173     try {
65174       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65175     } catch (std::out_of_range& e) {
65176       {
65177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65178       };
65179     } catch (std::exception& e) {
65180       {
65181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65182       };
65183     } catch (Dali::DaliException e) {
65184       {
65185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65186       };
65187     } catch (...) {
65188       {
65189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65190       };
65191     }
65192   }
65193
65194   jresult = (void *)result;
65195   return jresult;
65196 }
65197
65198
65199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65200   void * jresult ;
65201   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65202   Dali::Toolkit::CheckBoxButton *result = 0 ;
65203
65204   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65205   if (!arg1) {
65206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65207     return 0;
65208   }
65209   {
65210     try {
65211       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65212     } catch (std::out_of_range& e) {
65213       {
65214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65215       };
65216     } catch (std::exception& e) {
65217       {
65218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65219       };
65220     } catch (Dali::DaliException e) {
65221       {
65222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65223       };
65224     } catch (...) {
65225       {
65226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65227       };
65228     }
65229   }
65230
65231   jresult = (void *)result;
65232   return jresult;
65233 }
65234
65235
65236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65237   void * jresult ;
65238   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65239   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65240   Dali::Toolkit::CheckBoxButton *result = 0 ;
65241
65242   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65243   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65244   if (!arg2) {
65245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65246     return 0;
65247   }
65248   {
65249     try {
65250       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65251     } catch (std::out_of_range& e) {
65252       {
65253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65254       };
65255     } catch (std::exception& e) {
65256       {
65257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65258       };
65259     } catch (Dali::DaliException e) {
65260       {
65261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65262       };
65263     } catch (...) {
65264       {
65265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65266       };
65267     }
65268   }
65269
65270   jresult = (void *)result;
65271   return jresult;
65272 }
65273
65274
65275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65276   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65277
65278   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65279   {
65280     try {
65281       delete arg1;
65282     } catch (std::out_of_range& e) {
65283       {
65284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65285       };
65286     } catch (std::exception& e) {
65287       {
65288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65289       };
65290     } catch (Dali::DaliException e) {
65291       {
65292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65293       };
65294     } catch (...) {
65295       {
65296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65297       };
65298     }
65299   }
65300
65301 }
65302
65303
65304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65305   void * jresult ;
65306   Dali::Toolkit::CheckBoxButton result;
65307
65308   {
65309     try {
65310       result = Dali::Toolkit::CheckBoxButton::New();
65311     } catch (std::out_of_range& e) {
65312       {
65313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65314       };
65315     } catch (std::exception& e) {
65316       {
65317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65318       };
65319     } catch (Dali::DaliException e) {
65320       {
65321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65322       };
65323     } catch (...) {
65324       {
65325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65326       };
65327     }
65328   }
65329
65330   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65331   return jresult;
65332 }
65333
65334
65335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65336   void * jresult ;
65337   Dali::BaseHandle arg1 ;
65338   Dali::BaseHandle *argp1 ;
65339   Dali::Toolkit::CheckBoxButton result;
65340
65341   argp1 = (Dali::BaseHandle *)jarg1;
65342   if (!argp1) {
65343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65344     return 0;
65345   }
65346   arg1 = *argp1;
65347   {
65348     try {
65349       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65350     } catch (std::out_of_range& e) {
65351       {
65352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65353       };
65354     } catch (std::exception& e) {
65355       {
65356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65357       };
65358     } catch (Dali::DaliException e) {
65359       {
65360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65361       };
65362     } catch (...) {
65363       {
65364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65365       };
65366     }
65367   }
65368
65369   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65370   return jresult;
65371 }
65372
65373
65374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
65375   int jresult ;
65376   int result;
65377
65378   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65379   jresult = (int)result;
65380   return jresult;
65381 }
65382
65383
65384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
65385   int jresult ;
65386   int result;
65387
65388   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65389   jresult = (int)result;
65390   return jresult;
65391 }
65392
65393
65394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
65395   void * jresult ;
65396   Dali::Toolkit::PushButton::Property *result = 0 ;
65397
65398   {
65399     try {
65400       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65401     } catch (std::out_of_range& e) {
65402       {
65403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65404       };
65405     } catch (std::exception& e) {
65406       {
65407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65408       };
65409     } catch (Dali::DaliException e) {
65410       {
65411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65412       };
65413     } catch (...) {
65414       {
65415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65416       };
65417     }
65418   }
65419
65420   jresult = (void *)result;
65421   return jresult;
65422 }
65423
65424
65425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
65426   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65427
65428   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65429   {
65430     try {
65431       delete arg1;
65432     } catch (std::out_of_range& e) {
65433       {
65434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65435       };
65436     } catch (std::exception& e) {
65437       {
65438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65439       };
65440     } catch (Dali::DaliException e) {
65441       {
65442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65443       };
65444     } catch (...) {
65445       {
65446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65447       };
65448     }
65449   }
65450
65451 }
65452
65453
65454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65455   void * jresult ;
65456   Dali::Toolkit::PushButton *result = 0 ;
65457
65458   {
65459     try {
65460       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65461     } catch (std::out_of_range& e) {
65462       {
65463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65464       };
65465     } catch (std::exception& e) {
65466       {
65467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65468       };
65469     } catch (Dali::DaliException e) {
65470       {
65471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65472       };
65473     } catch (...) {
65474       {
65475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65476       };
65477     }
65478   }
65479
65480   jresult = (void *)result;
65481   return jresult;
65482 }
65483
65484
65485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
65486   void * jresult ;
65487   Dali::Toolkit::PushButton *arg1 = 0 ;
65488   Dali::Toolkit::PushButton *result = 0 ;
65489
65490   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65491   if (!arg1) {
65492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65493     return 0;
65494   }
65495   {
65496     try {
65497       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65498     } catch (std::out_of_range& e) {
65499       {
65500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65501       };
65502     } catch (std::exception& e) {
65503       {
65504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65505       };
65506     } catch (Dali::DaliException e) {
65507       {
65508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65509       };
65510     } catch (...) {
65511       {
65512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65513       };
65514     }
65515   }
65516
65517   jresult = (void *)result;
65518   return jresult;
65519 }
65520
65521
65522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
65523   void * jresult ;
65524   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65525   Dali::Toolkit::PushButton *arg2 = 0 ;
65526   Dali::Toolkit::PushButton *result = 0 ;
65527
65528   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65529   arg2 = (Dali::Toolkit::PushButton *)jarg2;
65530   if (!arg2) {
65531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65532     return 0;
65533   }
65534   {
65535     try {
65536       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
65537     } catch (std::out_of_range& e) {
65538       {
65539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65540       };
65541     } catch (std::exception& e) {
65542       {
65543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65544       };
65545     } catch (Dali::DaliException e) {
65546       {
65547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65548       };
65549     } catch (...) {
65550       {
65551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65552       };
65553     }
65554   }
65555
65556   jresult = (void *)result;
65557   return jresult;
65558 }
65559
65560
65561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
65562   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65563
65564   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65565   {
65566     try {
65567       delete arg1;
65568     } catch (std::out_of_range& e) {
65569       {
65570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65571       };
65572     } catch (std::exception& e) {
65573       {
65574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65575       };
65576     } catch (Dali::DaliException e) {
65577       {
65578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65579       };
65580     } catch (...) {
65581       {
65582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65583       };
65584     }
65585   }
65586
65587 }
65588
65589
65590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
65591   void * jresult ;
65592   Dali::Toolkit::PushButton result;
65593
65594   {
65595     try {
65596       result = Dali::Toolkit::PushButton::New();
65597     } catch (std::out_of_range& e) {
65598       {
65599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65600       };
65601     } catch (std::exception& e) {
65602       {
65603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65604       };
65605     } catch (Dali::DaliException e) {
65606       {
65607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65608       };
65609     } catch (...) {
65610       {
65611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65612       };
65613     }
65614   }
65615
65616   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65617   return jresult;
65618 }
65619
65620
65621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65622   void * jresult ;
65623   Dali::BaseHandle arg1 ;
65624   Dali::BaseHandle *argp1 ;
65625   Dali::Toolkit::PushButton result;
65626
65627   argp1 = (Dali::BaseHandle *)jarg1;
65628   if (!argp1) {
65629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65630     return 0;
65631   }
65632   arg1 = *argp1;
65633   {
65634     try {
65635       result = Dali::Toolkit::PushButton::DownCast(arg1);
65636     } catch (std::out_of_range& e) {
65637       {
65638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65639       };
65640     } catch (std::exception& e) {
65641       {
65642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65643       };
65644     } catch (Dali::DaliException e) {
65645       {
65646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65647       };
65648     } catch (...) {
65649       {
65650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65651       };
65652     }
65653   }
65654
65655   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65656   return jresult;
65657 }
65658
65659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65660   void * jresult ;
65661   Dali::Toolkit::RadioButton *result = 0 ;
65662
65663   {
65664     try {
65665       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65666     } catch (std::out_of_range& e) {
65667       {
65668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65669       };
65670     } catch (std::exception& e) {
65671       {
65672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65673       };
65674     } catch (Dali::DaliException e) {
65675       {
65676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65677       };
65678     } catch (...) {
65679       {
65680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65681       };
65682     }
65683   }
65684
65685   jresult = (void *)result;
65686   return jresult;
65687 }
65688
65689
65690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65691   void * jresult ;
65692   Dali::Toolkit::RadioButton *arg1 = 0 ;
65693   Dali::Toolkit::RadioButton *result = 0 ;
65694
65695   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65696   if (!arg1) {
65697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65698     return 0;
65699   }
65700   {
65701     try {
65702       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65703     } catch (std::out_of_range& e) {
65704       {
65705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65706       };
65707     } catch (std::exception& e) {
65708       {
65709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65710       };
65711     } catch (Dali::DaliException e) {
65712       {
65713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65714       };
65715     } catch (...) {
65716       {
65717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65718       };
65719     }
65720   }
65721
65722   jresult = (void *)result;
65723   return jresult;
65724 }
65725
65726
65727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65728   void * jresult ;
65729   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65730   Dali::Toolkit::RadioButton *arg2 = 0 ;
65731   Dali::Toolkit::RadioButton *result = 0 ;
65732
65733   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65734   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65735   if (!arg2) {
65736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65737     return 0;
65738   }
65739   {
65740     try {
65741       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65742     } catch (std::out_of_range& e) {
65743       {
65744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65745       };
65746     } catch (std::exception& e) {
65747       {
65748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65749       };
65750     } catch (Dali::DaliException e) {
65751       {
65752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65753       };
65754     } catch (...) {
65755       {
65756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65757       };
65758     }
65759   }
65760
65761   jresult = (void *)result;
65762   return jresult;
65763 }
65764
65765
65766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65767   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65768
65769   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65770   {
65771     try {
65772       delete arg1;
65773     } catch (std::out_of_range& e) {
65774       {
65775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65776       };
65777     } catch (std::exception& e) {
65778       {
65779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65780       };
65781     } catch (Dali::DaliException e) {
65782       {
65783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65784       };
65785     } catch (...) {
65786       {
65787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65788       };
65789     }
65790   }
65791
65792 }
65793
65794
65795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65796   void * jresult ;
65797   Dali::Toolkit::RadioButton result;
65798
65799   {
65800     try {
65801       result = Dali::Toolkit::RadioButton::New();
65802     } catch (std::out_of_range& e) {
65803       {
65804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65805       };
65806     } catch (std::exception& e) {
65807       {
65808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65809       };
65810     } catch (Dali::DaliException e) {
65811       {
65812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65813       };
65814     } catch (...) {
65815       {
65816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65817       };
65818     }
65819   }
65820
65821   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65822   return jresult;
65823 }
65824
65825
65826 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
65827   void * jresult ;
65828   std::string *arg1 = 0 ;
65829   Dali::Toolkit::RadioButton result;
65830
65831   if (!jarg1) {
65832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65833     return 0;
65834   }
65835   std::string arg1_str(jarg1);
65836   arg1 = &arg1_str;
65837   {
65838     try {
65839       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
65840     } catch (std::out_of_range& e) {
65841       {
65842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65843       };
65844     } catch (std::exception& e) {
65845       {
65846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65847       };
65848     } catch (Dali::DaliException e) {
65849       {
65850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65851       };
65852     } catch (...) {
65853       {
65854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65855       };
65856     }
65857   }
65858
65859   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65860
65861   //argout typemap for const std::string&
65862
65863   return jresult;
65864 }
65865
65866
65867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
65868   void * jresult ;
65869   Dali::BaseHandle arg1 ;
65870   Dali::BaseHandle *argp1 ;
65871   Dali::Toolkit::RadioButton result;
65872
65873   argp1 = (Dali::BaseHandle *)jarg1;
65874   if (!argp1) {
65875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65876     return 0;
65877   }
65878   arg1 = *argp1;
65879   {
65880     try {
65881       result = Dali::Toolkit::RadioButton::DownCast(arg1);
65882     } catch (std::out_of_range& e) {
65883       {
65884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65885       };
65886     } catch (std::exception& e) {
65887       {
65888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65889       };
65890     } catch (Dali::DaliException e) {
65891       {
65892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65893       };
65894     } catch (...) {
65895       {
65896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65897       };
65898     }
65899   }
65900
65901   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65902   return jresult;
65903 }
65904
65905
65906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
65907   int jresult ;
65908   int result;
65909
65910   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
65911   jresult = (int)result;
65912   return jresult;
65913 }
65914
65915
65916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
65917   int jresult ;
65918   int result;
65919
65920   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
65921   jresult = (int)result;
65922   return jresult;
65923 }
65924
65925
65926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
65927   int jresult ;
65928   int result;
65929
65930   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
65931   jresult = (int)result;
65932   return jresult;
65933 }
65934
65935
65936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
65937   int jresult ;
65938   int result;
65939
65940   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
65941   jresult = (int)result;
65942   return jresult;
65943 }
65944
65945
65946 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
65947   int jresult ;
65948   int result;
65949
65950   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
65951   jresult = (int)result;
65952   return jresult;
65953 }
65954
65955
65956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
65957   int jresult ;
65958   int result;
65959
65960   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
65961   jresult = (int)result;
65962   return jresult;
65963 }
65964
65965
65966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
65967   void * jresult ;
65968   Dali::Toolkit::FlexContainer::Property *result = 0 ;
65969
65970   {
65971     try {
65972       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
65973     } catch (std::out_of_range& e) {
65974       {
65975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65976       };
65977     } catch (std::exception& e) {
65978       {
65979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65980       };
65981     } catch (Dali::DaliException e) {
65982       {
65983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65984       };
65985     } catch (...) {
65986       {
65987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65988       };
65989     }
65990   }
65991
65992   jresult = (void *)result;
65993   return jresult;
65994 }
65995
65996
65997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
65998   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
65999
66000   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66001   {
66002     try {
66003       delete arg1;
66004     } catch (std::out_of_range& e) {
66005       {
66006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66007       };
66008     } catch (std::exception& e) {
66009       {
66010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66011       };
66012     } catch (Dali::DaliException e) {
66013       {
66014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66015       };
66016     } catch (...) {
66017       {
66018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66019       };
66020     }
66021   }
66022
66023 }
66024
66025
66026 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66027   int jresult ;
66028   int result;
66029
66030   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66031   jresult = (int)result;
66032   return jresult;
66033 }
66034
66035
66036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66037   int jresult ;
66038   int result;
66039
66040   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66041   jresult = (int)result;
66042   return jresult;
66043 }
66044
66045
66046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66047   int jresult ;
66048   int result;
66049
66050   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66051   jresult = (int)result;
66052   return jresult;
66053 }
66054
66055
66056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66057   void * jresult ;
66058   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66059
66060   {
66061     try {
66062       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66063     } catch (std::out_of_range& e) {
66064       {
66065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66066       };
66067     } catch (std::exception& e) {
66068       {
66069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66070       };
66071     } catch (Dali::DaliException e) {
66072       {
66073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66074       };
66075     } catch (...) {
66076       {
66077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66078       };
66079     }
66080   }
66081
66082   jresult = (void *)result;
66083   return jresult;
66084 }
66085
66086
66087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66088   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66089
66090   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66091   {
66092     try {
66093       delete arg1;
66094     } catch (std::out_of_range& e) {
66095       {
66096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66097       };
66098     } catch (std::exception& e) {
66099       {
66100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66101       };
66102     } catch (Dali::DaliException e) {
66103       {
66104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66105       };
66106     } catch (...) {
66107       {
66108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66109       };
66110     }
66111   }
66112
66113 }
66114
66115
66116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66117   void * jresult ;
66118   Dali::Toolkit::FlexContainer *result = 0 ;
66119
66120   {
66121     try {
66122       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66123     } catch (std::out_of_range& e) {
66124       {
66125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66126       };
66127     } catch (std::exception& e) {
66128       {
66129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66130       };
66131     } catch (Dali::DaliException e) {
66132       {
66133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66134       };
66135     } catch (...) {
66136       {
66137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66138       };
66139     }
66140   }
66141
66142   jresult = (void *)result;
66143   return jresult;
66144 }
66145
66146
66147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66148   void * jresult ;
66149   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66150   Dali::Toolkit::FlexContainer *result = 0 ;
66151
66152   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66153   if (!arg1) {
66154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66155     return 0;
66156   }
66157   {
66158     try {
66159       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66160     } catch (std::out_of_range& e) {
66161       {
66162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66163       };
66164     } catch (std::exception& e) {
66165       {
66166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66167       };
66168     } catch (Dali::DaliException e) {
66169       {
66170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66171       };
66172     } catch (...) {
66173       {
66174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66175       };
66176     }
66177   }
66178
66179   jresult = (void *)result;
66180   return jresult;
66181 }
66182
66183
66184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66185   void * jresult ;
66186   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66187   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66188   Dali::Toolkit::FlexContainer *result = 0 ;
66189
66190   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66191   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66192   if (!arg2) {
66193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66194     return 0;
66195   }
66196   {
66197     try {
66198       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66199     } catch (std::out_of_range& e) {
66200       {
66201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66202       };
66203     } catch (std::exception& e) {
66204       {
66205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66206       };
66207     } catch (Dali::DaliException e) {
66208       {
66209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66210       };
66211     } catch (...) {
66212       {
66213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66214       };
66215     }
66216   }
66217
66218   jresult = (void *)result;
66219   return jresult;
66220 }
66221
66222
66223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
66224   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66225
66226   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66227   {
66228     try {
66229       delete arg1;
66230     } catch (std::out_of_range& e) {
66231       {
66232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66233       };
66234     } catch (std::exception& e) {
66235       {
66236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66237       };
66238     } catch (Dali::DaliException e) {
66239       {
66240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66241       };
66242     } catch (...) {
66243       {
66244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66245       };
66246     }
66247   }
66248
66249 }
66250
66251
66252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
66253   void * jresult ;
66254   Dali::Toolkit::FlexContainer result;
66255
66256   {
66257     try {
66258       result = Dali::Toolkit::FlexContainer::New();
66259     } catch (std::out_of_range& e) {
66260       {
66261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66262       };
66263     } catch (std::exception& e) {
66264       {
66265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66266       };
66267     } catch (Dali::DaliException e) {
66268       {
66269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66270       };
66271     } catch (...) {
66272       {
66273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66274       };
66275     }
66276   }
66277
66278   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66279   return jresult;
66280 }
66281
66282
66283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66284   void * jresult ;
66285   Dali::BaseHandle arg1 ;
66286   Dali::BaseHandle *argp1 ;
66287   Dali::Toolkit::FlexContainer result;
66288
66289   argp1 = (Dali::BaseHandle *)jarg1;
66290   if (!argp1) {
66291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66292     return 0;
66293   }
66294   arg1 = *argp1;
66295   {
66296     try {
66297       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66298     } catch (std::out_of_range& e) {
66299       {
66300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66301       };
66302     } catch (std::exception& e) {
66303       {
66304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66305       };
66306     } catch (Dali::DaliException e) {
66307       {
66308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66309       };
66310     } catch (...) {
66311       {
66312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66313       };
66314     }
66315   }
66316
66317   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66318   return jresult;
66319 }
66320
66321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
66322   int jresult ;
66323   int result;
66324
66325   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66326   jresult = (int)result;
66327   return jresult;
66328 }
66329
66330
66331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66332   int jresult ;
66333   int result;
66334
66335   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66336   jresult = (int)result;
66337   return jresult;
66338 }
66339
66340
66341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
66342   int jresult ;
66343   int result;
66344
66345   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66346   jresult = (int)result;
66347   return jresult;
66348 }
66349
66350
66351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
66352   void * jresult ;
66353   Dali::Toolkit::ImageView::Property *result = 0 ;
66354
66355   {
66356     try {
66357       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
66358     } catch (std::out_of_range& e) {
66359       {
66360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66361       };
66362     } catch (std::exception& e) {
66363       {
66364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66365       };
66366     } catch (Dali::DaliException e) {
66367       {
66368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66369       };
66370     } catch (...) {
66371       {
66372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66373       };
66374     }
66375   }
66376
66377   jresult = (void *)result;
66378   return jresult;
66379 }
66380
66381
66382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
66383   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66384
66385   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66386   {
66387     try {
66388       delete arg1;
66389     } catch (std::out_of_range& e) {
66390       {
66391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66392       };
66393     } catch (std::exception& e) {
66394       {
66395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66396       };
66397     } catch (Dali::DaliException e) {
66398       {
66399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66400       };
66401     } catch (...) {
66402       {
66403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66404       };
66405     }
66406   }
66407
66408 }
66409
66410
66411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66412   void * jresult ;
66413   Dali::Toolkit::ImageView *result = 0 ;
66414
66415   {
66416     try {
66417       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66418     } catch (std::out_of_range& e) {
66419       {
66420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66421       };
66422     } catch (std::exception& e) {
66423       {
66424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66425       };
66426     } catch (Dali::DaliException e) {
66427       {
66428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66429       };
66430     } catch (...) {
66431       {
66432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66433       };
66434     }
66435   }
66436
66437   jresult = (void *)result;
66438   return jresult;
66439 }
66440
66441
66442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66443   void * jresult ;
66444   Dali::Toolkit::ImageView result;
66445
66446   {
66447     try {
66448       result = Dali::Toolkit::ImageView::New();
66449     } catch (std::out_of_range& e) {
66450       {
66451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66452       };
66453     } catch (std::exception& e) {
66454       {
66455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66456       };
66457     } catch (Dali::DaliException e) {
66458       {
66459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66460       };
66461     } catch (...) {
66462       {
66463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66464       };
66465     }
66466   }
66467
66468   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66469   return jresult;
66470 }
66471
66472
66473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66474   void * jresult ;
66475   std::string *arg1 = 0 ;
66476   Dali::Toolkit::ImageView result;
66477
66478   if (!jarg1) {
66479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66480     return 0;
66481   }
66482   std::string arg1_str(jarg1);
66483   arg1 = &arg1_str;
66484   {
66485     try {
66486       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66487     } catch (std::out_of_range& e) {
66488       {
66489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66490       };
66491     } catch (std::exception& e) {
66492       {
66493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66494       };
66495     } catch (Dali::DaliException e) {
66496       {
66497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66498       };
66499     } catch (...) {
66500       {
66501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66502       };
66503     }
66504   }
66505
66506   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66507
66508   //argout typemap for const std::string&
66509
66510   return jresult;
66511 }
66512
66513
66514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66515   void * jresult ;
66516   std::string *arg1 = 0 ;
66517   Dali::ImageDimensions arg2 ;
66518   Dali::ImageDimensions *argp2 ;
66519   Dali::Toolkit::ImageView result;
66520
66521   if (!jarg1) {
66522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66523     return 0;
66524   }
66525   std::string arg1_str(jarg1);
66526   arg1 = &arg1_str;
66527   argp2 = (Dali::ImageDimensions *)jarg2;
66528   if (!argp2) {
66529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66530     return 0;
66531   }
66532   arg2 = *argp2;
66533   {
66534     try {
66535       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66536     } catch (std::out_of_range& e) {
66537       {
66538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66539       };
66540     } catch (std::exception& e) {
66541       {
66542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66543       };
66544     } catch (Dali::DaliException e) {
66545       {
66546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66547       };
66548     } catch (...) {
66549       {
66550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66551       };
66552     }
66553   }
66554
66555   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66556
66557   //argout typemap for const std::string&
66558
66559   return jresult;
66560 }
66561
66562
66563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66564   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66565
66566   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66567   {
66568     try {
66569       delete arg1;
66570     } catch (std::out_of_range& e) {
66571       {
66572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66573       };
66574     } catch (std::exception& e) {
66575       {
66576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66577       };
66578     } catch (Dali::DaliException e) {
66579       {
66580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66581       };
66582     } catch (...) {
66583       {
66584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66585       };
66586     }
66587   }
66588
66589 }
66590
66591
66592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66593   void * jresult ;
66594   Dali::Toolkit::ImageView *arg1 = 0 ;
66595   Dali::Toolkit::ImageView *result = 0 ;
66596
66597   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66598   if (!arg1) {
66599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66600     return 0;
66601   }
66602   {
66603     try {
66604       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66605     } catch (std::out_of_range& e) {
66606       {
66607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66608       };
66609     } catch (std::exception& e) {
66610       {
66611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66612       };
66613     } catch (Dali::DaliException e) {
66614       {
66615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66616       };
66617     } catch (...) {
66618       {
66619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66620       };
66621     }
66622   }
66623
66624   jresult = (void *)result;
66625   return jresult;
66626 }
66627
66628
66629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66630   void * jresult ;
66631   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66632   Dali::Toolkit::ImageView *arg2 = 0 ;
66633   Dali::Toolkit::ImageView *result = 0 ;
66634
66635   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66636   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66637   if (!arg2) {
66638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66639     return 0;
66640   }
66641   {
66642     try {
66643       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66644     } catch (std::out_of_range& e) {
66645       {
66646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66647       };
66648     } catch (std::exception& e) {
66649       {
66650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66651       };
66652     } catch (Dali::DaliException e) {
66653       {
66654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66655       };
66656     } catch (...) {
66657       {
66658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66659       };
66660     }
66661   }
66662
66663   jresult = (void *)result;
66664   return jresult;
66665 }
66666
66667
66668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
66669   void * jresult ;
66670   Dali::BaseHandle arg1 ;
66671   Dali::BaseHandle *argp1 ;
66672   Dali::Toolkit::ImageView result;
66673
66674   argp1 = (Dali::BaseHandle *)jarg1;
66675   if (!argp1) {
66676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66677     return 0;
66678   }
66679   arg1 = *argp1;
66680   {
66681     try {
66682       result = Dali::Toolkit::ImageView::DownCast(arg1);
66683     } catch (std::out_of_range& e) {
66684       {
66685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66686       };
66687     } catch (std::exception& e) {
66688       {
66689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66690       };
66691     } catch (Dali::DaliException e) {
66692       {
66693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66694       };
66695     } catch (...) {
66696       {
66697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66698       };
66699     }
66700   }
66701
66702   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66703   return jresult;
66704 }
66705
66706
66707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
66708   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66709   std::string *arg2 = 0 ;
66710
66711   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66712   if (!jarg2) {
66713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66714     return ;
66715   }
66716   std::string arg2_str(jarg2);
66717   arg2 = &arg2_str;
66718   {
66719     try {
66720       (arg1)->SetImage((std::string const &)*arg2);
66721     } catch (std::out_of_range& e) {
66722       {
66723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66724       };
66725     } catch (std::exception& e) {
66726       {
66727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66728       };
66729     } catch (Dali::DaliException e) {
66730       {
66731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66732       };
66733     } catch (...) {
66734       {
66735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66736       };
66737     }
66738   }
66739
66740
66741   //argout typemap for const std::string&
66742
66743 }
66744
66745
66746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66747   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66748   std::string *arg2 = 0 ;
66749   Dali::ImageDimensions arg3 ;
66750   Dali::ImageDimensions *argp3 ;
66751
66752   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66753   if (!jarg2) {
66754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66755     return ;
66756   }
66757   std::string arg2_str(jarg2);
66758   arg2 = &arg2_str;
66759   argp3 = (Dali::ImageDimensions *)jarg3;
66760   if (!argp3) {
66761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66762     return ;
66763   }
66764   arg3 = *argp3;
66765   {
66766     try {
66767       (arg1)->SetImage((std::string const &)*arg2,arg3);
66768     } catch (std::out_of_range& e) {
66769       {
66770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66771       };
66772     } catch (std::exception& e) {
66773       {
66774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66775       };
66776     } catch (Dali::DaliException e) {
66777       {
66778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66779       };
66780     } catch (...) {
66781       {
66782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66783       };
66784     }
66785   }
66786
66787
66788   //argout typemap for const std::string&
66789
66790 }
66791
66792
66793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66794   int jresult ;
66795   int result;
66796
66797   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66798   jresult = (int)result;
66799   return jresult;
66800 }
66801
66802
66803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66804   int jresult ;
66805   int result;
66806
66807   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66808   jresult = (int)result;
66809   return jresult;
66810 }
66811
66812
66813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66814   int jresult ;
66815   int result;
66816
66817   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66818   jresult = (int)result;
66819   return jresult;
66820 }
66821
66822
66823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66824   int jresult ;
66825   int result;
66826
66827   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
66828   jresult = (int)result;
66829   return jresult;
66830 }
66831
66832
66833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
66834   int jresult ;
66835   int result;
66836
66837   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
66838   jresult = (int)result;
66839   return jresult;
66840 }
66841
66842
66843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
66844   int jresult ;
66845   int result;
66846
66847   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
66848   jresult = (int)result;
66849   return jresult;
66850 }
66851
66852
66853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
66854   int jresult ;
66855   int result;
66856
66857   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
66858   jresult = (int)result;
66859   return jresult;
66860 }
66861
66862
66863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
66864   int jresult ;
66865   int result;
66866
66867   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
66868   jresult = (int)result;
66869   return jresult;
66870 }
66871
66872
66873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
66874   void * jresult ;
66875   Dali::Toolkit::Model3dView::Property *result = 0 ;
66876
66877   {
66878     try {
66879       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
66880     } catch (std::out_of_range& e) {
66881       {
66882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66883       };
66884     } catch (std::exception& e) {
66885       {
66886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66887       };
66888     } catch (Dali::DaliException e) {
66889       {
66890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66891       };
66892     } catch (...) {
66893       {
66894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66895       };
66896     }
66897   }
66898
66899   jresult = (void *)result;
66900   return jresult;
66901 }
66902
66903
66904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
66905   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
66906
66907   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
66908   {
66909     try {
66910       delete arg1;
66911     } catch (std::out_of_range& e) {
66912       {
66913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66914       };
66915     } catch (std::exception& e) {
66916       {
66917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66918       };
66919     } catch (Dali::DaliException e) {
66920       {
66921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66922       };
66923     } catch (...) {
66924       {
66925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66926       };
66927     }
66928   }
66929
66930 }
66931
66932
66933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
66934   void * jresult ;
66935   Dali::Toolkit::Model3dView result;
66936
66937   {
66938     try {
66939       result = Dali::Toolkit::Model3dView::New();
66940     } catch (std::out_of_range& e) {
66941       {
66942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66943       };
66944     } catch (std::exception& e) {
66945       {
66946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66947       };
66948     } catch (Dali::DaliException e) {
66949       {
66950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66951       };
66952     } catch (...) {
66953       {
66954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66955       };
66956     }
66957   }
66958
66959   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66960   return jresult;
66961 }
66962
66963
66964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
66965   void * jresult ;
66966   std::string *arg1 = 0 ;
66967   std::string *arg2 = 0 ;
66968   std::string *arg3 = 0 ;
66969   Dali::Toolkit::Model3dView result;
66970
66971   if (!jarg1) {
66972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66973     return 0;
66974   }
66975   std::string arg1_str(jarg1);
66976   arg1 = &arg1_str;
66977   if (!jarg2) {
66978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66979     return 0;
66980   }
66981   std::string arg2_str(jarg2);
66982   arg2 = &arg2_str;
66983   if (!jarg3) {
66984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66985     return 0;
66986   }
66987   std::string arg3_str(jarg3);
66988   arg3 = &arg3_str;
66989   {
66990     try {
66991       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
66992     } catch (std::out_of_range& e) {
66993       {
66994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66995       };
66996     } catch (std::exception& e) {
66997       {
66998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66999       };
67000     } catch (Dali::DaliException e) {
67001       {
67002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67003       };
67004     } catch (...) {
67005       {
67006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67007       };
67008     }
67009   }
67010
67011   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67012
67013   //argout typemap for const std::string&
67014
67015
67016   //argout typemap for const std::string&
67017
67018
67019   //argout typemap for const std::string&
67020
67021   return jresult;
67022 }
67023
67024
67025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67026   void * jresult ;
67027   Dali::Toolkit::Model3dView *result = 0 ;
67028
67029   {
67030     try {
67031       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67032     } catch (std::out_of_range& e) {
67033       {
67034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67035       };
67036     } catch (std::exception& e) {
67037       {
67038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67039       };
67040     } catch (Dali::DaliException e) {
67041       {
67042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67043       };
67044     } catch (...) {
67045       {
67046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67047       };
67048     }
67049   }
67050
67051   jresult = (void *)result;
67052   return jresult;
67053 }
67054
67055
67056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67057   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67058
67059   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67060   {
67061     try {
67062       delete arg1;
67063     } catch (std::out_of_range& e) {
67064       {
67065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67066       };
67067     } catch (std::exception& e) {
67068       {
67069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67070       };
67071     } catch (Dali::DaliException e) {
67072       {
67073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67074       };
67075     } catch (...) {
67076       {
67077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67078       };
67079     }
67080   }
67081
67082 }
67083
67084
67085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67086   void * jresult ;
67087   Dali::Toolkit::Model3dView *arg1 = 0 ;
67088   Dali::Toolkit::Model3dView *result = 0 ;
67089
67090   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67091   if (!arg1) {
67092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67093     return 0;
67094   }
67095   {
67096     try {
67097       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67098     } catch (std::out_of_range& e) {
67099       {
67100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67101       };
67102     } catch (std::exception& e) {
67103       {
67104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67105       };
67106     } catch (Dali::DaliException e) {
67107       {
67108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67109       };
67110     } catch (...) {
67111       {
67112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67113       };
67114     }
67115   }
67116
67117   jresult = (void *)result;
67118   return jresult;
67119 }
67120
67121
67122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67123   void * jresult ;
67124   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67125   Dali::Toolkit::Model3dView *arg2 = 0 ;
67126   Dali::Toolkit::Model3dView *result = 0 ;
67127
67128   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67129   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67130   if (!arg2) {
67131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67132     return 0;
67133   }
67134   {
67135     try {
67136       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67137     } catch (std::out_of_range& e) {
67138       {
67139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67140       };
67141     } catch (std::exception& e) {
67142       {
67143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67144       };
67145     } catch (Dali::DaliException e) {
67146       {
67147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67148       };
67149     } catch (...) {
67150       {
67151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67152       };
67153     }
67154   }
67155
67156   jresult = (void *)result;
67157   return jresult;
67158 }
67159
67160
67161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67162   void * jresult ;
67163   Dali::BaseHandle arg1 ;
67164   Dali::BaseHandle *argp1 ;
67165   Dali::Toolkit::Model3dView result;
67166
67167   argp1 = (Dali::BaseHandle *)jarg1;
67168   if (!argp1) {
67169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67170     return 0;
67171   }
67172   arg1 = *argp1;
67173   {
67174     try {
67175       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67176     } catch (std::out_of_range& e) {
67177       {
67178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67179       };
67180     } catch (std::exception& e) {
67181       {
67182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67183       };
67184     } catch (Dali::DaliException e) {
67185       {
67186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67187       };
67188     } catch (...) {
67189       {
67190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67191       };
67192     }
67193   }
67194
67195   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67196   return jresult;
67197 }
67198
67199
67200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67201   int jresult ;
67202   int result;
67203
67204   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67205   jresult = (int)result;
67206   return jresult;
67207 }
67208
67209
67210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67211   int jresult ;
67212   int result;
67213
67214   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67215   jresult = (int)result;
67216   return jresult;
67217 }
67218
67219
67220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67221   int jresult ;
67222   int result;
67223
67224   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67225   jresult = (int)result;
67226   return jresult;
67227 }
67228
67229
67230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67231   int jresult ;
67232   int result;
67233
67234   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67235   jresult = (int)result;
67236   return jresult;
67237 }
67238
67239
67240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67241   int jresult ;
67242   int result;
67243
67244   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67245   jresult = (int)result;
67246   return jresult;
67247 }
67248
67249
67250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67251   int jresult ;
67252   int result;
67253
67254   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67255   jresult = (int)result;
67256   return jresult;
67257 }
67258
67259
67260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67261   int jresult ;
67262   int result;
67263
67264   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67265   jresult = (int)result;
67266   return jresult;
67267 }
67268
67269
67270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67271   int jresult ;
67272   int result;
67273
67274   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67275   jresult = (int)result;
67276   return jresult;
67277 }
67278
67279
67280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67281   int jresult ;
67282   int result;
67283
67284   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67285   jresult = (int)result;
67286   return jresult;
67287 }
67288
67289
67290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67291   void * jresult ;
67292   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67293
67294   {
67295     try {
67296       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67297     } catch (std::out_of_range& e) {
67298       {
67299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67300       };
67301     } catch (std::exception& e) {
67302       {
67303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67304       };
67305     } catch (Dali::DaliException e) {
67306       {
67307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67308       };
67309     } catch (...) {
67310       {
67311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67312       };
67313     }
67314   }
67315
67316   jresult = (void *)result;
67317   return jresult;
67318 }
67319
67320
67321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67322   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67323
67324   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67325   {
67326     try {
67327       delete arg1;
67328     } catch (std::out_of_range& e) {
67329       {
67330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67331       };
67332     } catch (std::exception& e) {
67333       {
67334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67335       };
67336     } catch (Dali::DaliException e) {
67337       {
67338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67339       };
67340     } catch (...) {
67341       {
67342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67343       };
67344     }
67345   }
67346
67347 }
67348
67349
67350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
67351   void * jresult ;
67352   Dali::Toolkit::ScrollBar *result = 0 ;
67353
67354   {
67355     try {
67356       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67357     } catch (std::out_of_range& e) {
67358       {
67359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67360       };
67361     } catch (std::exception& e) {
67362       {
67363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67364       };
67365     } catch (Dali::DaliException e) {
67366       {
67367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67368       };
67369     } catch (...) {
67370       {
67371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67372       };
67373     }
67374   }
67375
67376   jresult = (void *)result;
67377   return jresult;
67378 }
67379
67380
67381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
67382   void * jresult ;
67383   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67384   Dali::Toolkit::ScrollBar *result = 0 ;
67385
67386   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67387   if (!arg1) {
67388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67389     return 0;
67390   }
67391   {
67392     try {
67393       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
67394     } catch (std::out_of_range& e) {
67395       {
67396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67397       };
67398     } catch (std::exception& e) {
67399       {
67400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67401       };
67402     } catch (Dali::DaliException e) {
67403       {
67404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67405       };
67406     } catch (...) {
67407       {
67408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67409       };
67410     }
67411   }
67412
67413   jresult = (void *)result;
67414   return jresult;
67415 }
67416
67417
67418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
67419   void * jresult ;
67420   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67421   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67422   Dali::Toolkit::ScrollBar *result = 0 ;
67423
67424   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67425   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67426   if (!arg2) {
67427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67428     return 0;
67429   }
67430   {
67431     try {
67432       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67433     } catch (std::out_of_range& e) {
67434       {
67435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67436       };
67437     } catch (std::exception& e) {
67438       {
67439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67440       };
67441     } catch (Dali::DaliException e) {
67442       {
67443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67444       };
67445     } catch (...) {
67446       {
67447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67448       };
67449     }
67450   }
67451
67452   jresult = (void *)result;
67453   return jresult;
67454 }
67455
67456
67457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67458   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67459
67460   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67461   {
67462     try {
67463       delete arg1;
67464     } catch (std::out_of_range& e) {
67465       {
67466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67467       };
67468     } catch (std::exception& e) {
67469       {
67470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67471       };
67472     } catch (Dali::DaliException e) {
67473       {
67474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67475       };
67476     } catch (...) {
67477       {
67478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67479       };
67480     }
67481   }
67482
67483 }
67484
67485
67486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67487   void * jresult ;
67488   Dali::Toolkit::ScrollBar::Direction arg1 ;
67489   Dali::Toolkit::ScrollBar result;
67490
67491   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67492   {
67493     try {
67494       result = Dali::Toolkit::ScrollBar::New(arg1);
67495     } catch (std::out_of_range& e) {
67496       {
67497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67498       };
67499     } catch (std::exception& e) {
67500       {
67501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67502       };
67503     } catch (Dali::DaliException e) {
67504       {
67505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67506       };
67507     } catch (...) {
67508       {
67509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67510       };
67511     }
67512   }
67513
67514   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67515   return jresult;
67516 }
67517
67518
67519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67520   void * jresult ;
67521   Dali::Toolkit::ScrollBar result;
67522
67523   {
67524     try {
67525       result = Dali::Toolkit::ScrollBar::New();
67526     } catch (std::out_of_range& e) {
67527       {
67528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67529       };
67530     } catch (std::exception& e) {
67531       {
67532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67533       };
67534     } catch (Dali::DaliException e) {
67535       {
67536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67537       };
67538     } catch (...) {
67539       {
67540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67541       };
67542     }
67543   }
67544
67545   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67546   return jresult;
67547 }
67548
67549
67550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67551   void * jresult ;
67552   Dali::BaseHandle arg1 ;
67553   Dali::BaseHandle *argp1 ;
67554   Dali::Toolkit::ScrollBar result;
67555
67556   argp1 = (Dali::BaseHandle *)jarg1;
67557   if (!argp1) {
67558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67559     return 0;
67560   }
67561   arg1 = *argp1;
67562   {
67563     try {
67564       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67565     } catch (std::out_of_range& e) {
67566       {
67567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67568       };
67569     } catch (std::exception& e) {
67570       {
67571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67572       };
67573     } catch (Dali::DaliException e) {
67574       {
67575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67576       };
67577     } catch (...) {
67578       {
67579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67580       };
67581     }
67582   }
67583
67584   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67585   return jresult;
67586 }
67587
67588
67589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67590   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67591   Dali::Handle arg2 ;
67592   Dali::Property::Index arg3 ;
67593   Dali::Property::Index arg4 ;
67594   Dali::Property::Index arg5 ;
67595   Dali::Property::Index arg6 ;
67596   Dali::Handle *argp2 ;
67597
67598   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67599   argp2 = (Dali::Handle *)jarg2;
67600   if (!argp2) {
67601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67602     return ;
67603   }
67604   arg2 = *argp2;
67605   arg3 = (Dali::Property::Index)jarg3;
67606   arg4 = (Dali::Property::Index)jarg4;
67607   arg5 = (Dali::Property::Index)jarg5;
67608   arg6 = (Dali::Property::Index)jarg6;
67609   {
67610     try {
67611       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67612     } catch (std::out_of_range& e) {
67613       {
67614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67615       };
67616     } catch (std::exception& e) {
67617       {
67618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67619       };
67620     } catch (Dali::DaliException e) {
67621       {
67622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67623       };
67624     } catch (...) {
67625       {
67626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67627       };
67628     }
67629   }
67630
67631 }
67632
67633
67634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67635   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67636   Dali::Actor arg2 ;
67637   Dali::Actor *argp2 ;
67638
67639   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67640   argp2 = (Dali::Actor *)jarg2;
67641   if (!argp2) {
67642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67643     return ;
67644   }
67645   arg2 = *argp2;
67646   {
67647     try {
67648       (arg1)->SetScrollIndicator(arg2);
67649     } catch (std::out_of_range& e) {
67650       {
67651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67652       };
67653     } catch (std::exception& e) {
67654       {
67655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67656       };
67657     } catch (Dali::DaliException e) {
67658       {
67659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67660       };
67661     } catch (...) {
67662       {
67663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67664       };
67665     }
67666   }
67667
67668 }
67669
67670
67671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
67672   void * jresult ;
67673   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67674   Dali::Actor result;
67675
67676   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67677   {
67678     try {
67679       result = (arg1)->GetScrollIndicator();
67680     } catch (std::out_of_range& e) {
67681       {
67682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67683       };
67684     } catch (std::exception& e) {
67685       {
67686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67687       };
67688     } catch (Dali::DaliException e) {
67689       {
67690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67691       };
67692     } catch (...) {
67693       {
67694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67695       };
67696     }
67697   }
67698
67699   jresult = new Dali::Actor((const Dali::Actor &)result);
67700   return jresult;
67701 }
67702
67703
67704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
67705   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67706   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
67707
67708   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67709   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
67710   if (!arg2) {
67711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
67712     return ;
67713   }
67714   {
67715     try {
67716       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
67717     } catch (std::out_of_range& e) {
67718       {
67719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67720       };
67721     } catch (std::exception& e) {
67722       {
67723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67724       };
67725     } catch (Dali::DaliException e) {
67726       {
67727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67728       };
67729     } catch (...) {
67730       {
67731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67732       };
67733     }
67734   }
67735
67736 }
67737
67738
67739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
67740   void * jresult ;
67741   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67742
67743   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67744   {
67745     try {
67746       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()));
67747     } catch (std::out_of_range& e) {
67748       {
67749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67750       };
67751     } catch (std::exception& e) {
67752       {
67753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67754       };
67755     } catch (...) {
67756       {
67757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67758       };
67759     }
67760   }
67761   return jresult;
67762 }
67763
67764
67765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
67766   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67767   Dali::Toolkit::ScrollBar::Direction arg2 ;
67768
67769   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67770   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
67771   {
67772     try {
67773       (arg1)->SetScrollDirection(arg2);
67774     } catch (std::out_of_range& e) {
67775       {
67776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67777       };
67778     } catch (std::exception& e) {
67779       {
67780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67781       };
67782     } catch (Dali::DaliException e) {
67783       {
67784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67785       };
67786     } catch (...) {
67787       {
67788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67789       };
67790     }
67791   }
67792
67793 }
67794
67795
67796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
67797   int jresult ;
67798   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67799   Dali::Toolkit::ScrollBar::Direction result;
67800
67801   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67802   {
67803     try {
67804       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
67805     } catch (std::out_of_range& e) {
67806       {
67807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67808       };
67809     } catch (std::exception& e) {
67810       {
67811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67812       };
67813     } catch (Dali::DaliException e) {
67814       {
67815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67816       };
67817     } catch (...) {
67818       {
67819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67820       };
67821     }
67822   }
67823
67824   jresult = (int)result;
67825   return jresult;
67826 }
67827
67828
67829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
67830   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67831   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
67832
67833   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67834   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
67835   {
67836     try {
67837       (arg1)->SetIndicatorHeightPolicy(arg2);
67838     } catch (std::out_of_range& e) {
67839       {
67840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67841       };
67842     } catch (std::exception& e) {
67843       {
67844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67845       };
67846     } catch (Dali::DaliException e) {
67847       {
67848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67849       };
67850     } catch (...) {
67851       {
67852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67853       };
67854     }
67855   }
67856
67857 }
67858
67859
67860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
67861   int jresult ;
67862   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67863   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
67864
67865   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67866   {
67867     try {
67868       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
67869     } catch (std::out_of_range& e) {
67870       {
67871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67872       };
67873     } catch (std::exception& e) {
67874       {
67875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67876       };
67877     } catch (Dali::DaliException e) {
67878       {
67879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67880       };
67881     } catch (...) {
67882       {
67883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67884       };
67885     }
67886   }
67887
67888   jresult = (int)result;
67889   return jresult;
67890 }
67891
67892
67893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
67894   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67895   float arg2 ;
67896
67897   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67898   arg2 = (float)jarg2;
67899   {
67900     try {
67901       (arg1)->SetIndicatorFixedHeight(arg2);
67902     } catch (std::out_of_range& e) {
67903       {
67904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67905       };
67906     } catch (std::exception& e) {
67907       {
67908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67909       };
67910     } catch (Dali::DaliException e) {
67911       {
67912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67913       };
67914     } catch (...) {
67915       {
67916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67917       };
67918     }
67919   }
67920
67921 }
67922
67923
67924 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
67925   float jresult ;
67926   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67927   float result;
67928
67929   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67930   {
67931     try {
67932       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
67933     } catch (std::out_of_range& e) {
67934       {
67935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67936       };
67937     } catch (std::exception& e) {
67938       {
67939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67940       };
67941     } catch (Dali::DaliException e) {
67942       {
67943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67944       };
67945     } catch (...) {
67946       {
67947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67948       };
67949     }
67950   }
67951
67952   jresult = result;
67953   return jresult;
67954 }
67955
67956
67957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
67958   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67959   float arg2 ;
67960
67961   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67962   arg2 = (float)jarg2;
67963   {
67964     try {
67965       (arg1)->SetIndicatorShowDuration(arg2);
67966     } catch (std::out_of_range& e) {
67967       {
67968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67969       };
67970     } catch (std::exception& e) {
67971       {
67972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67973       };
67974     } catch (Dali::DaliException e) {
67975       {
67976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67977       };
67978     } catch (...) {
67979       {
67980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67981       };
67982     }
67983   }
67984
67985 }
67986
67987
67988 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
67989   float jresult ;
67990   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67991   float result;
67992
67993   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67994   {
67995     try {
67996       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
67997     } catch (std::out_of_range& e) {
67998       {
67999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68000       };
68001     } catch (std::exception& e) {
68002       {
68003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68004       };
68005     } catch (Dali::DaliException e) {
68006       {
68007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68008       };
68009     } catch (...) {
68010       {
68011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68012       };
68013     }
68014   }
68015
68016   jresult = result;
68017   return jresult;
68018 }
68019
68020
68021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68022   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68023   float arg2 ;
68024
68025   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68026   arg2 = (float)jarg2;
68027   {
68028     try {
68029       (arg1)->SetIndicatorHideDuration(arg2);
68030     } catch (std::out_of_range& e) {
68031       {
68032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68033       };
68034     } catch (std::exception& e) {
68035       {
68036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68037       };
68038     } catch (Dali::DaliException e) {
68039       {
68040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68041       };
68042     } catch (...) {
68043       {
68044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68045       };
68046     }
68047   }
68048
68049 }
68050
68051
68052 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68053   float jresult ;
68054   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68055   float result;
68056
68057   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68058   {
68059     try {
68060       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68061     } catch (std::out_of_range& e) {
68062       {
68063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68064       };
68065     } catch (std::exception& e) {
68066       {
68067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68068       };
68069     } catch (Dali::DaliException e) {
68070       {
68071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68072       };
68073     } catch (...) {
68074       {
68075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68076       };
68077     }
68078   }
68079
68080   jresult = result;
68081   return jresult;
68082 }
68083
68084
68085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68086   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68087
68088   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68089   {
68090     try {
68091       (arg1)->ShowIndicator();
68092     } catch (std::out_of_range& e) {
68093       {
68094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68095       };
68096     } catch (std::exception& e) {
68097       {
68098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68099       };
68100     } catch (Dali::DaliException e) {
68101       {
68102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68103       };
68104     } catch (...) {
68105       {
68106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68107       };
68108     }
68109   }
68110
68111 }
68112
68113
68114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68115   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68116
68117   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68118   {
68119     try {
68120       (arg1)->HideIndicator();
68121     } catch (std::out_of_range& e) {
68122       {
68123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68124       };
68125     } catch (std::exception& e) {
68126       {
68127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68128       };
68129     } catch (Dali::DaliException e) {
68130       {
68131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68132       };
68133     } catch (...) {
68134       {
68135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68136       };
68137     }
68138   }
68139
68140 }
68141
68142
68143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68144   void * jresult ;
68145   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68146   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68147
68148   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68149   {
68150     try {
68151       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68152     } catch (std::out_of_range& e) {
68153       {
68154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68155       };
68156     } catch (std::exception& e) {
68157       {
68158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68159       };
68160     } catch (Dali::DaliException e) {
68161       {
68162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68163       };
68164     } catch (...) {
68165       {
68166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68167       };
68168     }
68169   }
68170
68171   jresult = (void *)result;
68172   return jresult;
68173 }
68174
68175
68176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68177   void * jresult ;
68178   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68179   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68180
68181   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68182   {
68183     try {
68184       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68185     } catch (std::out_of_range& e) {
68186       {
68187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68188       };
68189     } catch (std::exception& e) {
68190       {
68191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68192       };
68193     } catch (Dali::DaliException e) {
68194       {
68195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68196       };
68197     } catch (...) {
68198       {
68199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68200       };
68201     }
68202   }
68203
68204   jresult = (void *)result;
68205   return jresult;
68206 }
68207
68208
68209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68210   int jresult ;
68211   int result;
68212
68213   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68214   jresult = (int)result;
68215   return jresult;
68216 }
68217
68218
68219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68220   int jresult ;
68221   int result;
68222
68223   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68224   jresult = (int)result;
68225   return jresult;
68226 }
68227
68228
68229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68230   int jresult ;
68231   int result;
68232
68233   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68234   jresult = (int)result;
68235   return jresult;
68236 }
68237
68238
68239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68240   int jresult ;
68241   int result;
68242
68243   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68244   jresult = (int)result;
68245   return jresult;
68246 }
68247
68248
68249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68250   int jresult ;
68251   int result;
68252
68253   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68254   jresult = (int)result;
68255   return jresult;
68256 }
68257
68258
68259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68260   int jresult ;
68261   int result;
68262
68263   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68264   jresult = (int)result;
68265   return jresult;
68266 }
68267
68268
68269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68270   int jresult ;
68271   int result;
68272
68273   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68274   jresult = (int)result;
68275   return jresult;
68276 }
68277
68278
68279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68280   int jresult ;
68281   int result;
68282
68283   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68284   jresult = (int)result;
68285   return jresult;
68286 }
68287
68288
68289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68290   int jresult ;
68291   int result;
68292
68293   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68294   jresult = (int)result;
68295   return jresult;
68296 }
68297
68298
68299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68300   int jresult ;
68301   int result;
68302
68303   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68304   jresult = (int)result;
68305   return jresult;
68306 }
68307
68308
68309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68310   int jresult ;
68311   int result;
68312
68313   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68314   jresult = (int)result;
68315   return jresult;
68316 }
68317
68318
68319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68320   int jresult ;
68321   int result;
68322
68323   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68324   jresult = (int)result;
68325   return jresult;
68326 }
68327
68328
68329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68330   int jresult ;
68331   int result;
68332
68333   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68334   jresult = (int)result;
68335   return jresult;
68336 }
68337
68338
68339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68340   int jresult ;
68341   int result;
68342
68343   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68344   jresult = (int)result;
68345   return jresult;
68346 }
68347
68348
68349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
68350   void * jresult ;
68351   Dali::Toolkit::Scrollable::Property *result = 0 ;
68352
68353   {
68354     try {
68355       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68356     } catch (std::out_of_range& e) {
68357       {
68358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68359       };
68360     } catch (std::exception& e) {
68361       {
68362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68363       };
68364     } catch (Dali::DaliException e) {
68365       {
68366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68367       };
68368     } catch (...) {
68369       {
68370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68371       };
68372     }
68373   }
68374
68375   jresult = (void *)result;
68376   return jresult;
68377 }
68378
68379
68380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
68381   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68382
68383   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68384   {
68385     try {
68386       delete arg1;
68387     } catch (std::out_of_range& e) {
68388       {
68389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68390       };
68391     } catch (std::exception& e) {
68392       {
68393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68394       };
68395     } catch (Dali::DaliException e) {
68396       {
68397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68398       };
68399     } catch (...) {
68400       {
68401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68402       };
68403     }
68404   }
68405
68406 }
68407
68408
68409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68410   void * jresult ;
68411   Dali::Toolkit::Scrollable *result = 0 ;
68412
68413   {
68414     try {
68415       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68416     } catch (std::out_of_range& e) {
68417       {
68418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68419       };
68420     } catch (std::exception& e) {
68421       {
68422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68423       };
68424     } catch (Dali::DaliException e) {
68425       {
68426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68427       };
68428     } catch (...) {
68429       {
68430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68431       };
68432     }
68433   }
68434
68435   jresult = (void *)result;
68436   return jresult;
68437 }
68438
68439
68440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68441   void * jresult ;
68442   Dali::Toolkit::Scrollable *arg1 = 0 ;
68443   Dali::Toolkit::Scrollable *result = 0 ;
68444
68445   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68446   if (!arg1) {
68447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68448     return 0;
68449   }
68450   {
68451     try {
68452       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68453     } catch (std::out_of_range& e) {
68454       {
68455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68456       };
68457     } catch (std::exception& e) {
68458       {
68459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68460       };
68461     } catch (Dali::DaliException e) {
68462       {
68463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68464       };
68465     } catch (...) {
68466       {
68467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68468       };
68469     }
68470   }
68471
68472   jresult = (void *)result;
68473   return jresult;
68474 }
68475
68476
68477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
68478   void * jresult ;
68479   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68480   Dali::Toolkit::Scrollable *arg2 = 0 ;
68481   Dali::Toolkit::Scrollable *result = 0 ;
68482
68483   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68484   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
68485   if (!arg2) {
68486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68487     return 0;
68488   }
68489   {
68490     try {
68491       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
68492     } catch (std::out_of_range& e) {
68493       {
68494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68495       };
68496     } catch (std::exception& e) {
68497       {
68498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68499       };
68500     } catch (Dali::DaliException e) {
68501       {
68502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68503       };
68504     } catch (...) {
68505       {
68506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68507       };
68508     }
68509   }
68510
68511   jresult = (void *)result;
68512   return jresult;
68513 }
68514
68515
68516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
68517   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68518
68519   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68520   {
68521     try {
68522       delete arg1;
68523     } catch (std::out_of_range& e) {
68524       {
68525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68526       };
68527     } catch (std::exception& e) {
68528       {
68529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68530       };
68531     } catch (Dali::DaliException e) {
68532       {
68533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68534       };
68535     } catch (...) {
68536       {
68537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68538       };
68539     }
68540   }
68541
68542 }
68543
68544
68545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
68546   void * jresult ;
68547   Dali::BaseHandle arg1 ;
68548   Dali::BaseHandle *argp1 ;
68549   Dali::Toolkit::Scrollable result;
68550
68551   argp1 = (Dali::BaseHandle *)jarg1;
68552   if (!argp1) {
68553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68554     return 0;
68555   }
68556   arg1 = *argp1;
68557   {
68558     try {
68559       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68560     } catch (std::out_of_range& e) {
68561       {
68562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68563       };
68564     } catch (std::exception& e) {
68565       {
68566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68567       };
68568     } catch (Dali::DaliException e) {
68569       {
68570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68571       };
68572     } catch (...) {
68573       {
68574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68575       };
68576     }
68577   }
68578
68579   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68580   return jresult;
68581 }
68582
68583
68584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68585   unsigned int jresult ;
68586   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68587   bool result;
68588
68589   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68590   {
68591     try {
68592       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68593     } catch (std::out_of_range& e) {
68594       {
68595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68596       };
68597     } catch (std::exception& e) {
68598       {
68599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68600       };
68601     } catch (Dali::DaliException e) {
68602       {
68603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68604       };
68605     } catch (...) {
68606       {
68607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68608       };
68609     }
68610   }
68611
68612   jresult = result;
68613   return jresult;
68614 }
68615
68616
68617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68618   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68619   bool arg2 ;
68620
68621   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68622   arg2 = jarg2 ? true : false;
68623   {
68624     try {
68625       (arg1)->SetOvershootEnabled(arg2);
68626     } catch (std::out_of_range& e) {
68627       {
68628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68629       };
68630     } catch (std::exception& e) {
68631       {
68632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68633       };
68634     } catch (Dali::DaliException e) {
68635       {
68636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68637       };
68638     } catch (...) {
68639       {
68640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68641       };
68642     }
68643   }
68644
68645 }
68646
68647
68648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68649   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68650   Dali::Vector4 *arg2 = 0 ;
68651
68652   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68653   arg2 = (Dali::Vector4 *)jarg2;
68654   if (!arg2) {
68655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68656     return ;
68657   }
68658   {
68659     try {
68660       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68661     } catch (std::out_of_range& e) {
68662       {
68663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68664       };
68665     } catch (std::exception& e) {
68666       {
68667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68668       };
68669     } catch (Dali::DaliException e) {
68670       {
68671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68672       };
68673     } catch (...) {
68674       {
68675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68676       };
68677     }
68678   }
68679
68680 }
68681
68682
68683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
68684   void * jresult ;
68685   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68686   Dali::Vector4 result;
68687
68688   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68689   {
68690     try {
68691       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68692     } catch (std::out_of_range& e) {
68693       {
68694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68695       };
68696     } catch (std::exception& e) {
68697       {
68698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68699       };
68700     } catch (Dali::DaliException e) {
68701       {
68702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68703       };
68704     } catch (...) {
68705       {
68706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68707       };
68708     }
68709   }
68710
68711   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68712   return jresult;
68713 }
68714
68715
68716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68717   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68718   float arg2 ;
68719
68720   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68721   arg2 = (float)jarg2;
68722   {
68723     try {
68724       (arg1)->SetOvershootAnimationSpeed(arg2);
68725     } catch (std::out_of_range& e) {
68726       {
68727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68728       };
68729     } catch (std::exception& e) {
68730       {
68731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68732       };
68733     } catch (Dali::DaliException e) {
68734       {
68735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68736       };
68737     } catch (...) {
68738       {
68739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68740       };
68741     }
68742   }
68743
68744 }
68745
68746
68747 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
68748   float jresult ;
68749   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68750   float result;
68751
68752   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68753   {
68754     try {
68755       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
68756     } catch (std::out_of_range& e) {
68757       {
68758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68759       };
68760     } catch (std::exception& e) {
68761       {
68762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68763       };
68764     } catch (Dali::DaliException e) {
68765       {
68766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68767       };
68768     } catch (...) {
68769       {
68770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68771       };
68772     }
68773   }
68774
68775   jresult = result;
68776   return jresult;
68777 }
68778
68779
68780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
68781   void * jresult ;
68782   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68783   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
68784
68785   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68786   {
68787     try {
68788       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
68789     } catch (std::out_of_range& e) {
68790       {
68791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68792       };
68793     } catch (std::exception& e) {
68794       {
68795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68796       };
68797     } catch (Dali::DaliException e) {
68798       {
68799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68800       };
68801     } catch (...) {
68802       {
68803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68804       };
68805     }
68806   }
68807
68808   jresult = (void *)result;
68809   return jresult;
68810 }
68811
68812
68813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
68814   void * jresult ;
68815   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68816   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
68817
68818   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68819   {
68820     try {
68821       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
68822     } catch (std::out_of_range& e) {
68823       {
68824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68825       };
68826     } catch (std::exception& e) {
68827       {
68828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68829       };
68830     } catch (Dali::DaliException e) {
68831       {
68832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68833       };
68834     } catch (...) {
68835       {
68836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68837       };
68838     }
68839   }
68840
68841   jresult = (void *)result;
68842   return jresult;
68843 }
68844
68845
68846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
68847   void * jresult ;
68848   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68849   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
68850
68851   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68852   {
68853     try {
68854       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
68855     } catch (std::out_of_range& e) {
68856       {
68857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68858       };
68859     } catch (std::exception& e) {
68860       {
68861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68862       };
68863     } catch (Dali::DaliException e) {
68864       {
68865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68866       };
68867     } catch (...) {
68868       {
68869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68870       };
68871     }
68872   }
68873
68874   jresult = (void *)result;
68875   return jresult;
68876 }
68877
68878
68879 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
68880   unsigned int jresult ;
68881   Dali::Toolkit::ControlOrientation::Type arg1 ;
68882   bool result;
68883
68884   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68885   {
68886     try {
68887       result = (bool)Dali::Toolkit::IsVertical(arg1);
68888     } catch (std::out_of_range& e) {
68889       {
68890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68891       };
68892     } catch (std::exception& e) {
68893       {
68894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68895       };
68896     } catch (Dali::DaliException e) {
68897       {
68898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68899       };
68900     } catch (...) {
68901       {
68902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68903       };
68904     }
68905   }
68906
68907   jresult = result;
68908   return jresult;
68909 }
68910
68911
68912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
68913   unsigned int jresult ;
68914   Dali::Toolkit::ControlOrientation::Type arg1 ;
68915   bool result;
68916
68917   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68918   {
68919     try {
68920       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
68921     } catch (std::out_of_range& e) {
68922       {
68923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68924       };
68925     } catch (std::exception& e) {
68926       {
68927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68928       };
68929     } catch (Dali::DaliException e) {
68930       {
68931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68932       };
68933     } catch (...) {
68934       {
68935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68936       };
68937     }
68938   }
68939
68940   jresult = result;
68941   return jresult;
68942 }
68943
68944
68945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
68946   void * jresult ;
68947   unsigned int arg1 ;
68948   unsigned int arg2 ;
68949   Dali::Toolkit::ItemRange *result = 0 ;
68950
68951   arg1 = (unsigned int)jarg1;
68952   arg2 = (unsigned int)jarg2;
68953   {
68954     try {
68955       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
68956     } catch (std::out_of_range& e) {
68957       {
68958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68959       };
68960     } catch (std::exception& e) {
68961       {
68962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68963       };
68964     } catch (Dali::DaliException e) {
68965       {
68966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68967       };
68968     } catch (...) {
68969       {
68970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68971       };
68972     }
68973   }
68974
68975   jresult = (void *)result;
68976   return jresult;
68977 }
68978
68979
68980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
68981   void * jresult ;
68982   Dali::Toolkit::ItemRange *arg1 = 0 ;
68983   Dali::Toolkit::ItemRange *result = 0 ;
68984
68985   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
68986   if (!arg1) {
68987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
68988     return 0;
68989   }
68990   {
68991     try {
68992       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
68993     } catch (std::out_of_range& e) {
68994       {
68995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68996       };
68997     } catch (std::exception& e) {
68998       {
68999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69000       };
69001     } catch (Dali::DaliException e) {
69002       {
69003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69004       };
69005     } catch (...) {
69006       {
69007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69008       };
69009     }
69010   }
69011
69012   jresult = (void *)result;
69013   return jresult;
69014 }
69015
69016
69017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69018   void * jresult ;
69019   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69020   Dali::Toolkit::ItemRange *arg2 = 0 ;
69021   Dali::Toolkit::ItemRange *result = 0 ;
69022
69023   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69024   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69025   if (!arg2) {
69026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69027     return 0;
69028   }
69029   {
69030     try {
69031       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69032     } catch (std::out_of_range& e) {
69033       {
69034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69035       };
69036     } catch (std::exception& e) {
69037       {
69038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69039       };
69040     } catch (Dali::DaliException e) {
69041       {
69042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69043       };
69044     } catch (...) {
69045       {
69046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69047       };
69048     }
69049   }
69050
69051   jresult = (void *)result;
69052   return jresult;
69053 }
69054
69055
69056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69057   unsigned int jresult ;
69058   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69059   unsigned int arg2 ;
69060   bool result;
69061
69062   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69063   arg2 = (unsigned int)jarg2;
69064   {
69065     try {
69066       result = (bool)(arg1)->Within(arg2);
69067     } catch (std::out_of_range& e) {
69068       {
69069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69070       };
69071     } catch (std::exception& e) {
69072       {
69073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69074       };
69075     } catch (Dali::DaliException e) {
69076       {
69077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69078       };
69079     } catch (...) {
69080       {
69081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69082       };
69083     }
69084   }
69085
69086   jresult = result;
69087   return jresult;
69088 }
69089
69090
69091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69092   void * jresult ;
69093   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69094   Dali::Toolkit::ItemRange *arg2 = 0 ;
69095   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69096
69097   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69098   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69099   if (!arg2) {
69100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69101     return 0;
69102   }
69103   {
69104     try {
69105       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69106     } catch (std::out_of_range& e) {
69107       {
69108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69109       };
69110     } catch (std::exception& e) {
69111       {
69112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69113       };
69114     } catch (Dali::DaliException e) {
69115       {
69116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69117       };
69118     } catch (...) {
69119       {
69120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69121       };
69122     }
69123   }
69124
69125   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69126   return jresult;
69127 }
69128
69129
69130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69131   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69132   unsigned int arg2 ;
69133
69134   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69135   arg2 = (unsigned int)jarg2;
69136   if (arg1) (arg1)->begin = arg2;
69137 }
69138
69139
69140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
69141   unsigned int jresult ;
69142   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69143   unsigned int result;
69144
69145   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69146   result = (unsigned int) ((arg1)->begin);
69147   jresult = result;
69148   return jresult;
69149 }
69150
69151
69152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69153   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69154   unsigned int arg2 ;
69155
69156   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69157   arg2 = (unsigned int)jarg2;
69158   if (arg1) (arg1)->end = arg2;
69159 }
69160
69161
69162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69163   unsigned int jresult ;
69164   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69165   unsigned int result;
69166
69167   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69168   result = (unsigned int) ((arg1)->end);
69169   jresult = result;
69170   return jresult;
69171 }
69172
69173
69174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69175   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69176
69177   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69178   {
69179     try {
69180       delete arg1;
69181     } catch (std::out_of_range& e) {
69182       {
69183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69184       };
69185     } catch (std::exception& e) {
69186       {
69187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69188       };
69189     } catch (Dali::DaliException e) {
69190       {
69191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69192       };
69193     } catch (...) {
69194       {
69195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69196       };
69197     }
69198   }
69199
69200 }
69201
69202
69203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69204   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69205
69206   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69207   {
69208     try {
69209       delete arg1;
69210     } catch (std::out_of_range& e) {
69211       {
69212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69213       };
69214     } catch (std::exception& e) {
69215       {
69216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69217       };
69218     } catch (Dali::DaliException e) {
69219       {
69220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69221       };
69222     } catch (...) {
69223       {
69224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69225       };
69226     }
69227   }
69228
69229 }
69230
69231
69232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69233   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69234   Dali::Toolkit::ControlOrientation::Type arg2 ;
69235
69236   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69237   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69238   {
69239     try {
69240       (arg1)->SetOrientation(arg2);
69241     } catch (std::out_of_range& e) {
69242       {
69243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69244       };
69245     } catch (std::exception& e) {
69246       {
69247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69248       };
69249     } catch (Dali::DaliException e) {
69250       {
69251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69252       };
69253     } catch (...) {
69254       {
69255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69256       };
69257     }
69258   }
69259
69260 }
69261
69262
69263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69264   int jresult ;
69265   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69266   Dali::Toolkit::ControlOrientation::Type result;
69267
69268   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69269   {
69270     try {
69271       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69272     } catch (std::out_of_range& e) {
69273       {
69274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69275       };
69276     } catch (std::exception& e) {
69277       {
69278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69279       };
69280     } catch (Dali::DaliException e) {
69281       {
69282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69283       };
69284     } catch (...) {
69285       {
69286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69287       };
69288     }
69289   }
69290
69291   jresult = (int)result;
69292   return jresult;
69293 }
69294
69295
69296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69297   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69298   Dali::Property::Map *arg2 = 0 ;
69299
69300   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69301   arg2 = (Dali::Property::Map *)jarg2;
69302   if (!arg2) {
69303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69304     return ;
69305   }
69306   {
69307     try {
69308       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69309     } catch (std::out_of_range& e) {
69310       {
69311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69312       };
69313     } catch (std::exception& e) {
69314       {
69315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69316       };
69317     } catch (Dali::DaliException e) {
69318       {
69319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69320       };
69321     } catch (...) {
69322       {
69323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69324       };
69325     }
69326   }
69327
69328 }
69329
69330
69331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69332   void * jresult ;
69333   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69334   Dali::Property::Map result;
69335
69336   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69337   {
69338     try {
69339       result = (arg1)->GetLayoutProperties();
69340     } catch (std::out_of_range& e) {
69341       {
69342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69343       };
69344     } catch (std::exception& e) {
69345       {
69346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69347       };
69348     } catch (Dali::DaliException e) {
69349       {
69350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69351       };
69352     } catch (...) {
69353       {
69354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69355       };
69356     }
69357   }
69358
69359   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69360   return jresult;
69361 }
69362
69363
69364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69365   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69366   unsigned int arg2 ;
69367   Dali::Vector3 *arg3 = 0 ;
69368   Dali::Vector3 *arg4 = 0 ;
69369
69370   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69371   arg2 = (unsigned int)jarg2;
69372   arg3 = (Dali::Vector3 *)jarg3;
69373   if (!arg3) {
69374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69375     return ;
69376   }
69377   arg4 = (Dali::Vector3 *)jarg4;
69378   if (!arg4) {
69379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69380     return ;
69381   }
69382   {
69383     try {
69384       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69385     } catch (std::out_of_range& e) {
69386       {
69387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69388       };
69389     } catch (std::exception& e) {
69390       {
69391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69392       };
69393     } catch (Dali::DaliException e) {
69394       {
69395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69396       };
69397     } catch (...) {
69398       {
69399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69400       };
69401     }
69402   }
69403
69404 }
69405
69406
69407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69408   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69409   Dali::Vector3 *arg2 = 0 ;
69410
69411   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69412   arg2 = (Dali::Vector3 *)jarg2;
69413   if (!arg2) {
69414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69415     return ;
69416   }
69417   {
69418     try {
69419       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69420     } catch (std::out_of_range& e) {
69421       {
69422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69423       };
69424     } catch (std::exception& e) {
69425       {
69426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69427       };
69428     } catch (Dali::DaliException e) {
69429       {
69430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69431       };
69432     } catch (...) {
69433       {
69434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69435       };
69436     }
69437   }
69438
69439 }
69440
69441
69442 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69443   float jresult ;
69444   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69445   unsigned int arg2 ;
69446   Dali::Vector3 arg3 ;
69447   Dali::Vector3 *argp3 ;
69448   float result;
69449
69450   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69451   arg2 = (unsigned int)jarg2;
69452   argp3 = (Dali::Vector3 *)jarg3;
69453   if (!argp3) {
69454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69455     return 0;
69456   }
69457   arg3 = *argp3;
69458   {
69459     try {
69460       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69461     } catch (std::out_of_range& e) {
69462       {
69463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69464       };
69465     } catch (std::exception& e) {
69466       {
69467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69468       };
69469     } catch (Dali::DaliException e) {
69470       {
69471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69472       };
69473     } catch (...) {
69474       {
69475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69476       };
69477     }
69478   }
69479
69480   jresult = result;
69481   return jresult;
69482 }
69483
69484
69485 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69486   float jresult ;
69487   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69488   float arg2 ;
69489   float result;
69490
69491   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69492   arg2 = (float)jarg2;
69493   {
69494     try {
69495       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69496     } catch (std::out_of_range& e) {
69497       {
69498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69499       };
69500     } catch (std::exception& e) {
69501       {
69502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69503       };
69504     } catch (Dali::DaliException e) {
69505       {
69506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69507       };
69508     } catch (...) {
69509       {
69510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69511       };
69512     }
69513   }
69514
69515   jresult = result;
69516   return jresult;
69517 }
69518
69519
69520 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
69521   float jresult ;
69522   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69523   unsigned int arg2 ;
69524   float result;
69525
69526   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69527   arg2 = (unsigned int)jarg2;
69528   {
69529     try {
69530       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
69531     } catch (std::out_of_range& e) {
69532       {
69533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69534       };
69535     } catch (std::exception& e) {
69536       {
69537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69538       };
69539     } catch (Dali::DaliException e) {
69540       {
69541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69542       };
69543     } catch (...) {
69544       {
69545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69546       };
69547     }
69548   }
69549
69550   jresult = result;
69551   return jresult;
69552 }
69553
69554
69555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
69556   void * jresult ;
69557   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69558   float arg2 ;
69559   Dali::Vector3 arg3 ;
69560   Dali::Vector3 *argp3 ;
69561   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69562
69563   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69564   arg2 = (float)jarg2;
69565   argp3 = (Dali::Vector3 *)jarg3;
69566   if (!argp3) {
69567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69568     return 0;
69569   }
69570   arg3 = *argp3;
69571   {
69572     try {
69573       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69574     } catch (std::out_of_range& e) {
69575       {
69576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69577       };
69578     } catch (std::exception& e) {
69579       {
69580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69581       };
69582     } catch (Dali::DaliException e) {
69583       {
69584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69585       };
69586     } catch (...) {
69587       {
69588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69589       };
69590     }
69591   }
69592
69593   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69594   return jresult;
69595 }
69596
69597
69598 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69599   float jresult ;
69600   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69601   int arg2 ;
69602   float arg3 ;
69603   Dali::Vector3 *arg4 = 0 ;
69604   float result;
69605
69606   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69607   arg2 = (int)jarg2;
69608   arg3 = (float)jarg3;
69609   arg4 = (Dali::Vector3 *)jarg4;
69610   if (!arg4) {
69611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69612     return 0;
69613   }
69614   {
69615     try {
69616       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69617     } catch (std::out_of_range& e) {
69618       {
69619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69620       };
69621     } catch (std::exception& e) {
69622       {
69623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69624       };
69625     } catch (Dali::DaliException e) {
69626       {
69627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69628       };
69629     } catch (...) {
69630       {
69631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69632       };
69633     }
69634   }
69635
69636   jresult = result;
69637   return jresult;
69638 }
69639
69640
69641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
69642   unsigned int jresult ;
69643   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69644   Dali::Vector3 arg2 ;
69645   Dali::Vector3 *argp2 ;
69646   unsigned int result;
69647
69648   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69649   argp2 = (Dali::Vector3 *)jarg2;
69650   if (!argp2) {
69651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69652     return 0;
69653   }
69654   arg2 = *argp2;
69655   {
69656     try {
69657       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
69658     } catch (std::out_of_range& e) {
69659       {
69660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69661       };
69662     } catch (std::exception& e) {
69663       {
69664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69665       };
69666     } catch (Dali::DaliException e) {
69667       {
69668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69669       };
69670     } catch (...) {
69671       {
69672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69673       };
69674     }
69675   }
69676
69677   jresult = result;
69678   return jresult;
69679 }
69680
69681
69682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69683   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69684   unsigned int arg2 ;
69685   Dali::Vector3 *arg3 = 0 ;
69686   Dali::Vector3 *arg4 = 0 ;
69687
69688   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69689   arg2 = (unsigned int)jarg2;
69690   arg3 = (Dali::Vector3 *)jarg3;
69691   if (!arg3) {
69692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69693     return ;
69694   }
69695   arg4 = (Dali::Vector3 *)jarg4;
69696   if (!arg4) {
69697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69698     return ;
69699   }
69700   {
69701     try {
69702       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69703     } catch (std::out_of_range& e) {
69704       {
69705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69706       };
69707     } catch (std::exception& e) {
69708       {
69709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69710       };
69711     } catch (Dali::DaliException e) {
69712       {
69713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69714       };
69715     } catch (...) {
69716       {
69717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69718       };
69719     }
69720   }
69721
69722 }
69723
69724
69725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
69726   void * jresult ;
69727   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69728   Dali::Degree result;
69729
69730   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69731   {
69732     try {
69733       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69734     } catch (std::out_of_range& e) {
69735       {
69736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69737       };
69738     } catch (std::exception& e) {
69739       {
69740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69741       };
69742     } catch (Dali::DaliException e) {
69743       {
69744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69745       };
69746     } catch (...) {
69747       {
69748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69749       };
69750     }
69751   }
69752
69753   jresult = new Dali::Degree((const Dali::Degree &)result);
69754   return jresult;
69755 }
69756
69757
69758 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
69759   float jresult ;
69760   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69761   float result;
69762
69763   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69764   {
69765     try {
69766       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
69767     } catch (std::out_of_range& e) {
69768       {
69769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69770       };
69771     } catch (std::exception& e) {
69772       {
69773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69774       };
69775     } catch (Dali::DaliException e) {
69776       {
69777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69778       };
69779     } catch (...) {
69780       {
69781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69782       };
69783     }
69784   }
69785
69786   jresult = result;
69787   return jresult;
69788 }
69789
69790
69791 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
69792   float jresult ;
69793   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69794   float result;
69795
69796   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69797   {
69798     try {
69799       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
69800     } catch (std::out_of_range& e) {
69801       {
69802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69803       };
69804     } catch (std::exception& e) {
69805       {
69806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69807       };
69808     } catch (Dali::DaliException e) {
69809       {
69810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69811       };
69812     } catch (...) {
69813       {
69814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69815       };
69816     }
69817   }
69818
69819   jresult = result;
69820   return jresult;
69821 }
69822
69823
69824 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
69825   float jresult ;
69826   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69827   float result;
69828
69829   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69830   {
69831     try {
69832       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
69833     } catch (std::out_of_range& e) {
69834       {
69835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69836       };
69837     } catch (std::exception& e) {
69838       {
69839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69840       };
69841     } catch (Dali::DaliException e) {
69842       {
69843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69844       };
69845     } catch (...) {
69846       {
69847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69848       };
69849     }
69850   }
69851
69852   jresult = result;
69853   return jresult;
69854 }
69855
69856
69857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
69858   int jresult ;
69859   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69860   int arg2 ;
69861   int arg3 ;
69862   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
69863   bool arg5 ;
69864   int result;
69865
69866   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69867   arg2 = (int)jarg2;
69868   arg3 = (int)jarg3;
69869   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
69870   arg5 = jarg5 ? true : false;
69871   {
69872     try {
69873       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
69874     } catch (std::out_of_range& e) {
69875       {
69876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69877       };
69878     } catch (std::exception& e) {
69879       {
69880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69881       };
69882     } catch (Dali::DaliException e) {
69883       {
69884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69885       };
69886     } catch (...) {
69887       {
69888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69889       };
69890     }
69891   }
69892
69893   jresult = result;
69894   return jresult;
69895 }
69896
69897
69898 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
69899   float jresult ;
69900   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69901   float result;
69902
69903   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69904   {
69905     try {
69906       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
69907     } catch (std::out_of_range& e) {
69908       {
69909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69910       };
69911     } catch (std::exception& e) {
69912       {
69913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69914       };
69915     } catch (Dali::DaliException e) {
69916       {
69917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69918       };
69919     } catch (...) {
69920       {
69921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69922       };
69923     }
69924   }
69925
69926   jresult = result;
69927   return jresult;
69928 }
69929
69930
69931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
69932   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69933   Dali::Actor *arg2 = 0 ;
69934   int arg3 ;
69935   Dali::Vector3 *arg4 = 0 ;
69936   Dali::Actor *arg5 = 0 ;
69937
69938   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69939   arg2 = (Dali::Actor *)jarg2;
69940   if (!arg2) {
69941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
69942     return ;
69943   }
69944   arg3 = (int)jarg3;
69945   arg4 = (Dali::Vector3 *)jarg4;
69946   if (!arg4) {
69947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69948     return ;
69949   }
69950   arg5 = (Dali::Actor *)jarg5;
69951   if (!arg5) {
69952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
69953     return ;
69954   }
69955   {
69956     try {
69957       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
69958     } catch (std::out_of_range& e) {
69959       {
69960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69961       };
69962     } catch (std::exception& e) {
69963       {
69964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69965       };
69966     } catch (Dali::DaliException e) {
69967       {
69968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69969       };
69970     } catch (...) {
69971       {
69972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69973       };
69974     }
69975   }
69976
69977 }
69978
69979
69980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69981   void * jresult ;
69982   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69983   int arg2 ;
69984   float arg3 ;
69985   Dali::Vector3 *arg4 = 0 ;
69986   Dali::Vector3 result;
69987
69988   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69989   arg2 = (int)jarg2;
69990   arg3 = (float)jarg3;
69991   arg4 = (Dali::Vector3 *)jarg4;
69992   if (!arg4) {
69993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69994     return 0;
69995   }
69996   {
69997     try {
69998       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69999     } catch (std::out_of_range& e) {
70000       {
70001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70002       };
70003     } catch (std::exception& e) {
70004       {
70005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70006       };
70007     } catch (Dali::DaliException e) {
70008       {
70009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70010       };
70011     } catch (...) {
70012       {
70013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70014       };
70015     }
70016   }
70017
70018   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70019   return jresult;
70020 }
70021
70022
70023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70024   void * jresult ;
70025   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70026   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70027
70028   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70029   {
70030     try {
70031       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70032     } catch (std::out_of_range& e) {
70033       {
70034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70035       };
70036     } catch (std::exception& e) {
70037       {
70038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70039       };
70040     } catch (Dali::DaliException e) {
70041       {
70042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70043       };
70044     } catch (...) {
70045       {
70046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70047       };
70048     }
70049   }
70050
70051   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70052   return jresult;
70053 }
70054
70055
70056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70057   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70058
70059   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70060   {
70061     try {
70062       delete arg1;
70063     } catch (std::out_of_range& e) {
70064       {
70065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70066       };
70067     } catch (std::exception& e) {
70068       {
70069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70070       };
70071     } catch (Dali::DaliException e) {
70072       {
70073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70074       };
70075     } catch (...) {
70076       {
70077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70078       };
70079     }
70080   }
70081
70082 }
70083
70084
70085 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70086   unsigned int jresult ;
70087   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70088   unsigned int result;
70089
70090   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70091   {
70092     try {
70093       result = (unsigned int)(arg1)->GetNumberOfItems();
70094     } catch (std::out_of_range& e) {
70095       {
70096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70097       };
70098     } catch (std::exception& e) {
70099       {
70100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70101       };
70102     } catch (Dali::DaliException e) {
70103       {
70104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70105       };
70106     } catch (...) {
70107       {
70108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70109       };
70110     }
70111   }
70112
70113   jresult = result;
70114   return jresult;
70115 }
70116
70117
70118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70119   void * jresult ;
70120   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70121   unsigned int arg2 ;
70122   Dali::Actor result;
70123
70124   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70125   arg2 = (unsigned int)jarg2;
70126   {
70127     try {
70128       result = (arg1)->NewItem(arg2);
70129     } catch (std::out_of_range& e) {
70130       {
70131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70132       };
70133     } catch (std::exception& e) {
70134       {
70135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70136       };
70137     } catch (Dali::DaliException e) {
70138       {
70139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70140       };
70141     } catch (...) {
70142       {
70143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70144       };
70145     }
70146   }
70147
70148   jresult = new Dali::Actor((const Dali::Actor &)result);
70149   return jresult;
70150 }
70151
70152
70153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70154   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70155   unsigned int arg2 ;
70156   Dali::Actor arg3 ;
70157   Dali::Actor *argp3 ;
70158
70159   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70160   arg2 = (unsigned int)jarg2;
70161   argp3 = (Dali::Actor *)jarg3;
70162   if (!argp3) {
70163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70164     return ;
70165   }
70166   arg3 = *argp3;
70167   {
70168     try {
70169       (arg1)->ItemReleased(arg2,arg3);
70170     } catch (std::out_of_range& e) {
70171       {
70172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70173       };
70174     } catch (std::exception& e) {
70175       {
70176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70177       };
70178     } catch (Dali::DaliException e) {
70179       {
70180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70181       };
70182     } catch (...) {
70183       {
70184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70185       };
70186     }
70187   }
70188
70189 }
70190
70191
70192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70193   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70194   unsigned int arg2 ;
70195   Dali::Actor arg3 ;
70196   Dali::Actor *argp3 ;
70197
70198   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70199   arg2 = (unsigned int)jarg2;
70200   argp3 = (Dali::Actor *)jarg3;
70201   if (!argp3) {
70202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70203     return ;
70204   }
70205   arg3 = *argp3;
70206   {
70207     try {
70208       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70209     } catch (std::out_of_range& e) {
70210       {
70211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70212       };
70213     } catch (std::exception& e) {
70214       {
70215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70216       };
70217     } catch (Dali::DaliException e) {
70218       {
70219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70220       };
70221     } catch (...) {
70222       {
70223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70224       };
70225     }
70226   }
70227
70228 }
70229
70230
70231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70232   void * jresult ;
70233   Dali::Toolkit::ItemFactory *result = 0 ;
70234
70235   {
70236     try {
70237       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70238     } catch (std::out_of_range& e) {
70239       {
70240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70241       };
70242     } catch (std::exception& e) {
70243       {
70244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70245       };
70246     } catch (Dali::DaliException e) {
70247       {
70248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70249       };
70250     } catch (...) {
70251       {
70252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70253       };
70254     }
70255   }
70256
70257   jresult = (void *)result;
70258   return jresult;
70259 }
70260
70261
70262 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) {
70263   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70264   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70265   if (director) {
70266     director->swig_connect_director(callback0, callback1, callback2);
70267   }
70268 }
70269
70270
70271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70272   int jresult ;
70273   int result;
70274
70275   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70276   jresult = (int)result;
70277   return jresult;
70278 }
70279
70280
70281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70282   int jresult ;
70283   int result;
70284
70285   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70286   jresult = (int)result;
70287   return jresult;
70288 }
70289
70290
70291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70292   int jresult ;
70293   int result;
70294
70295   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70296   jresult = (int)result;
70297   return jresult;
70298 }
70299
70300
70301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70302   int jresult ;
70303   int result;
70304
70305   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70306   jresult = (int)result;
70307   return jresult;
70308 }
70309
70310
70311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70312   int jresult ;
70313   int result;
70314
70315   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70316   jresult = (int)result;
70317   return jresult;
70318 }
70319
70320
70321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70322   int jresult ;
70323   int result;
70324
70325   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70326   jresult = (int)result;
70327   return jresult;
70328 }
70329
70330
70331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70332   int jresult ;
70333   int result;
70334
70335   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70336   jresult = (int)result;
70337   return jresult;
70338 }
70339
70340
70341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70342   int jresult ;
70343   int result;
70344
70345   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70346   jresult = (int)result;
70347   return jresult;
70348 }
70349
70350
70351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70352   int jresult ;
70353   int result;
70354
70355   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70356   jresult = (int)result;
70357   return jresult;
70358 }
70359
70360
70361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70362   int jresult ;
70363   int result;
70364
70365   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70366   jresult = (int)result;
70367   return jresult;
70368 }
70369
70370
70371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70372   int jresult ;
70373   int result;
70374
70375   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70376   jresult = (int)result;
70377   return jresult;
70378 }
70379
70380
70381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70382   void * jresult ;
70383   Dali::Toolkit::ItemView::Property *result = 0 ;
70384
70385   {
70386     try {
70387       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70388     } catch (std::out_of_range& e) {
70389       {
70390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70391       };
70392     } catch (std::exception& e) {
70393       {
70394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70395       };
70396     } catch (Dali::DaliException e) {
70397       {
70398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70399       };
70400     } catch (...) {
70401       {
70402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70403       };
70404     }
70405   }
70406
70407   jresult = (void *)result;
70408   return jresult;
70409 }
70410
70411
70412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70413   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70414
70415   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70416   {
70417     try {
70418       delete arg1;
70419     } catch (std::out_of_range& e) {
70420       {
70421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70422       };
70423     } catch (std::exception& e) {
70424       {
70425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70426       };
70427     } catch (Dali::DaliException e) {
70428       {
70429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70430       };
70431     } catch (...) {
70432       {
70433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70434       };
70435     }
70436   }
70437
70438 }
70439
70440
70441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70442   void * jresult ;
70443   Dali::Toolkit::ItemView *result = 0 ;
70444
70445   {
70446     try {
70447       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70448     } catch (std::out_of_range& e) {
70449       {
70450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70451       };
70452     } catch (std::exception& e) {
70453       {
70454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70455       };
70456     } catch (Dali::DaliException e) {
70457       {
70458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70459       };
70460     } catch (...) {
70461       {
70462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70463       };
70464     }
70465   }
70466
70467   jresult = (void *)result;
70468   return jresult;
70469 }
70470
70471
70472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70473   void * jresult ;
70474   Dali::Toolkit::ItemView *arg1 = 0 ;
70475   Dali::Toolkit::ItemView *result = 0 ;
70476
70477   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70478   if (!arg1) {
70479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70480     return 0;
70481   }
70482   {
70483     try {
70484       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70485     } catch (std::out_of_range& e) {
70486       {
70487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70488       };
70489     } catch (std::exception& e) {
70490       {
70491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70492       };
70493     } catch (Dali::DaliException e) {
70494       {
70495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70496       };
70497     } catch (...) {
70498       {
70499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70500       };
70501     }
70502   }
70503
70504   jresult = (void *)result;
70505   return jresult;
70506 }
70507
70508
70509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70510   void * jresult ;
70511   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70512   Dali::Toolkit::ItemView *arg2 = 0 ;
70513   Dali::Toolkit::ItemView *result = 0 ;
70514
70515   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70516   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70517   if (!arg2) {
70518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70519     return 0;
70520   }
70521   {
70522     try {
70523       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70524     } catch (std::out_of_range& e) {
70525       {
70526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70527       };
70528     } catch (std::exception& e) {
70529       {
70530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70531       };
70532     } catch (Dali::DaliException e) {
70533       {
70534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70535       };
70536     } catch (...) {
70537       {
70538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70539       };
70540     }
70541   }
70542
70543   jresult = (void *)result;
70544   return jresult;
70545 }
70546
70547
70548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70549   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70550
70551   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70552   {
70553     try {
70554       delete arg1;
70555     } catch (std::out_of_range& e) {
70556       {
70557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70558       };
70559     } catch (std::exception& e) {
70560       {
70561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70562       };
70563     } catch (Dali::DaliException e) {
70564       {
70565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70566       };
70567     } catch (...) {
70568       {
70569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70570       };
70571     }
70572   }
70573
70574 }
70575
70576
70577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70578   void * jresult ;
70579   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70580   Dali::Toolkit::ItemView result;
70581
70582   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70583   if (!arg1) {
70584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70585     return 0;
70586   }
70587   {
70588     try {
70589       result = Dali::Toolkit::ItemView::New(*arg1);
70590     } catch (std::out_of_range& e) {
70591       {
70592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70593       };
70594     } catch (std::exception& e) {
70595       {
70596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70597       };
70598     } catch (Dali::DaliException e) {
70599       {
70600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70601       };
70602     } catch (...) {
70603       {
70604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70605       };
70606     }
70607   }
70608
70609   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70610   return jresult;
70611 }
70612
70613
70614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70615   void * jresult ;
70616   Dali::BaseHandle arg1 ;
70617   Dali::BaseHandle *argp1 ;
70618   Dali::Toolkit::ItemView result;
70619
70620   argp1 = (Dali::BaseHandle *)jarg1;
70621   if (!argp1) {
70622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70623     return 0;
70624   }
70625   arg1 = *argp1;
70626   {
70627     try {
70628       result = Dali::Toolkit::ItemView::DownCast(arg1);
70629     } catch (std::out_of_range& e) {
70630       {
70631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70632       };
70633     } catch (std::exception& e) {
70634       {
70635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70636       };
70637     } catch (Dali::DaliException e) {
70638       {
70639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70640       };
70641     } catch (...) {
70642       {
70643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70644       };
70645     }
70646   }
70647
70648   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70649   return jresult;
70650 }
70651
70652
70653 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
70654   unsigned int jresult ;
70655   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70656   unsigned int result;
70657
70658   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70659   {
70660     try {
70661       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
70662     } catch (std::out_of_range& e) {
70663       {
70664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70665       };
70666     } catch (std::exception& e) {
70667       {
70668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70669       };
70670     } catch (Dali::DaliException e) {
70671       {
70672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70673       };
70674     } catch (...) {
70675       {
70676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70677       };
70678     }
70679   }
70680
70681   jresult = result;
70682   return jresult;
70683 }
70684
70685
70686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
70687   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70688   Dali::Toolkit::ItemLayout *arg2 = 0 ;
70689
70690   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70691   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
70692   if (!arg2) {
70693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
70694     return ;
70695   }
70696   {
70697     try {
70698       (arg1)->AddLayout(*arg2);
70699     } catch (std::out_of_range& e) {
70700       {
70701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70702       };
70703     } catch (std::exception& e) {
70704       {
70705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70706       };
70707     } catch (Dali::DaliException e) {
70708       {
70709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70710       };
70711     } catch (...) {
70712       {
70713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70714       };
70715     }
70716   }
70717
70718 }
70719
70720
70721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
70722   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70723   unsigned int arg2 ;
70724
70725   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70726   arg2 = (unsigned int)jarg2;
70727   {
70728     try {
70729       (arg1)->RemoveLayout(arg2);
70730     } catch (std::out_of_range& e) {
70731       {
70732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70733       };
70734     } catch (std::exception& e) {
70735       {
70736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70737       };
70738     } catch (Dali::DaliException e) {
70739       {
70740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70741       };
70742     } catch (...) {
70743       {
70744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70745       };
70746     }
70747   }
70748
70749 }
70750
70751
70752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70753   void * jresult ;
70754   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70755   unsigned int arg2 ;
70756   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70757
70758   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70759   arg2 = (unsigned int)jarg2;
70760   {
70761     try {
70762       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
70763     } catch (std::out_of_range& e) {
70764       {
70765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70766       };
70767     } catch (std::exception& e) {
70768       {
70769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70770       };
70771     } catch (Dali::DaliException e) {
70772       {
70773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70774       };
70775     } catch (...) {
70776       {
70777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70778       };
70779     }
70780   }
70781
70782   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70783   return jresult;
70784 }
70785
70786
70787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
70788   void * jresult ;
70789   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70790   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70791
70792   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70793   {
70794     try {
70795       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
70796     } catch (std::out_of_range& e) {
70797       {
70798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70799       };
70800     } catch (std::exception& e) {
70801       {
70802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70803       };
70804     } catch (Dali::DaliException e) {
70805       {
70806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70807       };
70808     } catch (...) {
70809       {
70810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70811       };
70812     }
70813   }
70814
70815   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70816   return jresult;
70817 }
70818
70819
70820 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
70821   float jresult ;
70822   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70823   Dali::Toolkit::ItemId arg2 ;
70824   float result;
70825
70826   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70827   arg2 = (Dali::Toolkit::ItemId)jarg2;
70828   {
70829     try {
70830       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
70831     } catch (std::out_of_range& e) {
70832       {
70833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70834       };
70835     } catch (std::exception& e) {
70836       {
70837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70838       };
70839     } catch (Dali::DaliException e) {
70840       {
70841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70842       };
70843     } catch (...) {
70844       {
70845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70846       };
70847     }
70848   }
70849
70850   jresult = result;
70851   return jresult;
70852 }
70853
70854
70855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
70856   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70857   unsigned int arg2 ;
70858   Dali::Vector3 arg3 ;
70859   float arg4 ;
70860   Dali::Vector3 *argp3 ;
70861
70862   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70863   arg2 = (unsigned int)jarg2;
70864   argp3 = (Dali::Vector3 *)jarg3;
70865   if (!argp3) {
70866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70867     return ;
70868   }
70869   arg3 = *argp3;
70870   arg4 = (float)jarg4;
70871   {
70872     try {
70873       (arg1)->ActivateLayout(arg2,arg3,arg4);
70874     } catch (std::out_of_range& e) {
70875       {
70876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70877       };
70878     } catch (std::exception& e) {
70879       {
70880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70881       };
70882     } catch (Dali::DaliException e) {
70883       {
70884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70885       };
70886     } catch (...) {
70887       {
70888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70889       };
70890     }
70891   }
70892
70893 }
70894
70895
70896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
70897   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70898
70899   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70900   {
70901     try {
70902       (arg1)->DeactivateCurrentLayout();
70903     } catch (std::out_of_range& e) {
70904       {
70905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70906       };
70907     } catch (std::exception& e) {
70908       {
70909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70910       };
70911     } catch (Dali::DaliException e) {
70912       {
70913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70914       };
70915     } catch (...) {
70916       {
70917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70918       };
70919     }
70920   }
70921
70922 }
70923
70924
70925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
70926   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70927   float arg2 ;
70928
70929   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70930   arg2 = (float)jarg2;
70931   {
70932     try {
70933       (arg1)->SetMinimumSwipeSpeed(arg2);
70934     } catch (std::out_of_range& e) {
70935       {
70936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70937       };
70938     } catch (std::exception& e) {
70939       {
70940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70941       };
70942     } catch (Dali::DaliException e) {
70943       {
70944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70945       };
70946     } catch (...) {
70947       {
70948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70949       };
70950     }
70951   }
70952
70953 }
70954
70955
70956 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
70957   float jresult ;
70958   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70959   float result;
70960
70961   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70962   {
70963     try {
70964       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
70965     } catch (std::out_of_range& e) {
70966       {
70967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70968       };
70969     } catch (std::exception& e) {
70970       {
70971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70972       };
70973     } catch (Dali::DaliException e) {
70974       {
70975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70976       };
70977     } catch (...) {
70978       {
70979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70980       };
70981     }
70982   }
70983
70984   jresult = result;
70985   return jresult;
70986 }
70987
70988
70989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
70990   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70991   float arg2 ;
70992
70993   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70994   arg2 = (float)jarg2;
70995   {
70996     try {
70997       (arg1)->SetMinimumSwipeDistance(arg2);
70998     } catch (std::out_of_range& e) {
70999       {
71000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71001       };
71002     } catch (std::exception& e) {
71003       {
71004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71005       };
71006     } catch (Dali::DaliException e) {
71007       {
71008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71009       };
71010     } catch (...) {
71011       {
71012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71013       };
71014     }
71015   }
71016
71017 }
71018
71019
71020 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71021   float jresult ;
71022   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71023   float result;
71024
71025   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71026   {
71027     try {
71028       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71029     } catch (std::out_of_range& e) {
71030       {
71031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71032       };
71033     } catch (std::exception& e) {
71034       {
71035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71036       };
71037     } catch (Dali::DaliException e) {
71038       {
71039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71040       };
71041     } catch (...) {
71042       {
71043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71044       };
71045     }
71046   }
71047
71048   jresult = result;
71049   return jresult;
71050 }
71051
71052
71053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71054   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71055   float arg2 ;
71056
71057   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71058   arg2 = (float)jarg2;
71059   {
71060     try {
71061       (arg1)->SetWheelScrollDistanceStep(arg2);
71062     } catch (std::out_of_range& e) {
71063       {
71064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71065       };
71066     } catch (std::exception& e) {
71067       {
71068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71069       };
71070     } catch (Dali::DaliException e) {
71071       {
71072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71073       };
71074     } catch (...) {
71075       {
71076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71077       };
71078     }
71079   }
71080
71081 }
71082
71083
71084 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71085   float jresult ;
71086   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71087   float result;
71088
71089   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71090   {
71091     try {
71092       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71093     } catch (std::out_of_range& e) {
71094       {
71095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71096       };
71097     } catch (std::exception& e) {
71098       {
71099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71100       };
71101     } catch (Dali::DaliException e) {
71102       {
71103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71104       };
71105     } catch (...) {
71106       {
71107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71108       };
71109     }
71110   }
71111
71112   jresult = result;
71113   return jresult;
71114 }
71115
71116
71117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71118   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71119   bool arg2 ;
71120
71121   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71122   arg2 = jarg2 ? true : false;
71123   {
71124     try {
71125       (arg1)->SetAnchoring(arg2);
71126     } catch (std::out_of_range& e) {
71127       {
71128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71129       };
71130     } catch (std::exception& e) {
71131       {
71132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71133       };
71134     } catch (Dali::DaliException e) {
71135       {
71136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71137       };
71138     } catch (...) {
71139       {
71140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71141       };
71142     }
71143   }
71144
71145 }
71146
71147 //// ========================= end of part 3 =============================
71148
71149 //// ========================== start part 4 ===============================
71150
71151
71152 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71153   unsigned int jresult ;
71154   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71155   bool result;
71156
71157   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71158   {
71159     try {
71160       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71161     } catch (std::out_of_range& e) {
71162       {
71163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71164       };
71165     } catch (std::exception& e) {
71166       {
71167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71168       };
71169     } catch (Dali::DaliException e) {
71170       {
71171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71172       };
71173     } catch (...) {
71174       {
71175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71176       };
71177     }
71178   }
71179
71180   jresult = result;
71181   return jresult;
71182 }
71183
71184
71185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71186   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71187   float arg2 ;
71188
71189   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71190   arg2 = (float)jarg2;
71191   {
71192     try {
71193       (arg1)->SetAnchoringDuration(arg2);
71194     } catch (std::out_of_range& e) {
71195       {
71196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71197       };
71198     } catch (std::exception& e) {
71199       {
71200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71201       };
71202     } catch (Dali::DaliException e) {
71203       {
71204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71205       };
71206     } catch (...) {
71207       {
71208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71209       };
71210     }
71211   }
71212
71213 }
71214
71215
71216 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71217   float jresult ;
71218   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71219   float result;
71220
71221   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71222   {
71223     try {
71224       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71225     } catch (std::out_of_range& e) {
71226       {
71227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71228       };
71229     } catch (std::exception& e) {
71230       {
71231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71232       };
71233     } catch (Dali::DaliException e) {
71234       {
71235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71236       };
71237     } catch (...) {
71238       {
71239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71240       };
71241     }
71242   }
71243
71244   jresult = result;
71245   return jresult;
71246 }
71247
71248
71249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71250   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71251   Dali::Toolkit::ItemId arg2 ;
71252   float arg3 ;
71253
71254   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71255   arg2 = (Dali::Toolkit::ItemId)jarg2;
71256   arg3 = (float)jarg3;
71257   {
71258     try {
71259       (arg1)->ScrollToItem(arg2,arg3);
71260     } catch (std::out_of_range& e) {
71261       {
71262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71263       };
71264     } catch (std::exception& e) {
71265       {
71266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71267       };
71268     } catch (Dali::DaliException e) {
71269       {
71270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71271       };
71272     } catch (...) {
71273       {
71274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71275       };
71276     }
71277   }
71278
71279 }
71280
71281
71282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71283   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71284   float arg2 ;
71285
71286   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71287   arg2 = (float)jarg2;
71288   {
71289     try {
71290       (arg1)->SetRefreshInterval(arg2);
71291     } catch (std::out_of_range& e) {
71292       {
71293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71294       };
71295     } catch (std::exception& e) {
71296       {
71297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71298       };
71299     } catch (Dali::DaliException e) {
71300       {
71301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71302       };
71303     } catch (...) {
71304       {
71305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71306       };
71307     }
71308   }
71309
71310 }
71311
71312
71313 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71314   float jresult ;
71315   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71316   float result;
71317
71318   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71319   {
71320     try {
71321       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71322     } catch (std::out_of_range& e) {
71323       {
71324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71325       };
71326     } catch (std::exception& e) {
71327       {
71328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71329       };
71330     } catch (Dali::DaliException e) {
71331       {
71332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71333       };
71334     } catch (...) {
71335       {
71336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71337       };
71338     }
71339   }
71340
71341   jresult = result;
71342   return jresult;
71343 }
71344
71345
71346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71347   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71348
71349   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71350   {
71351     try {
71352       (arg1)->Refresh();
71353     } catch (std::out_of_range& e) {
71354       {
71355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71356       };
71357     } catch (std::exception& e) {
71358       {
71359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71360       };
71361     } catch (Dali::DaliException e) {
71362       {
71363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71364       };
71365     } catch (...) {
71366       {
71367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71368       };
71369     }
71370   }
71371
71372 }
71373
71374
71375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71376   void * jresult ;
71377   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71378   Dali::Toolkit::ItemId arg2 ;
71379   Dali::Actor result;
71380
71381   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71382   arg2 = (Dali::Toolkit::ItemId)jarg2;
71383   {
71384     try {
71385       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71386     } catch (std::out_of_range& e) {
71387       {
71388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71389       };
71390     } catch (std::exception& e) {
71391       {
71392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71393       };
71394     } catch (Dali::DaliException e) {
71395       {
71396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71397       };
71398     } catch (...) {
71399       {
71400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71401       };
71402     }
71403   }
71404
71405   jresult = new Dali::Actor((const Dali::Actor &)result);
71406   return jresult;
71407 }
71408
71409
71410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71411   unsigned int jresult ;
71412   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71413   Dali::Actor arg2 ;
71414   Dali::Actor *argp2 ;
71415   Dali::Toolkit::ItemId result;
71416
71417   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71418   argp2 = (Dali::Actor *)jarg2;
71419   if (!argp2) {
71420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71421     return 0;
71422   }
71423   arg2 = *argp2;
71424   {
71425     try {
71426       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71427     } catch (std::out_of_range& e) {
71428       {
71429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71430       };
71431     } catch (std::exception& e) {
71432       {
71433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71434       };
71435     } catch (Dali::DaliException e) {
71436       {
71437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71438       };
71439     } catch (...) {
71440       {
71441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71442       };
71443     }
71444   }
71445
71446   jresult = result;
71447   return jresult;
71448 }
71449
71450
71451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71452   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71453   Dali::Toolkit::Item arg2 ;
71454   float arg3 ;
71455   Dali::Toolkit::Item *argp2 ;
71456
71457   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71458   argp2 = (Dali::Toolkit::Item *)jarg2;
71459   if (!argp2) {
71460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71461     return ;
71462   }
71463   arg2 = *argp2;
71464   arg3 = (float)jarg3;
71465   {
71466     try {
71467       (arg1)->InsertItem(arg2,arg3);
71468     } catch (std::out_of_range& e) {
71469       {
71470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71471       };
71472     } catch (std::exception& e) {
71473       {
71474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71475       };
71476     } catch (Dali::DaliException e) {
71477       {
71478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71479       };
71480     } catch (...) {
71481       {
71482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71483       };
71484     }
71485   }
71486
71487 }
71488
71489
71490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71491   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71492   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71493   float arg3 ;
71494
71495   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71496   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71497   if (!arg2) {
71498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71499     return ;
71500   }
71501   arg3 = (float)jarg3;
71502   {
71503     try {
71504       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71505     } catch (std::out_of_range& e) {
71506       {
71507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71508       };
71509     } catch (std::exception& e) {
71510       {
71511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71512       };
71513     } catch (Dali::DaliException e) {
71514       {
71515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71516       };
71517     } catch (...) {
71518       {
71519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71520       };
71521     }
71522   }
71523
71524 }
71525
71526
71527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71528   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71529   Dali::Toolkit::ItemId arg2 ;
71530   float arg3 ;
71531
71532   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71533   arg2 = (Dali::Toolkit::ItemId)jarg2;
71534   arg3 = (float)jarg3;
71535   {
71536     try {
71537       (arg1)->RemoveItem(arg2,arg3);
71538     } catch (std::out_of_range& e) {
71539       {
71540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71541       };
71542     } catch (std::exception& e) {
71543       {
71544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71545       };
71546     } catch (Dali::DaliException e) {
71547       {
71548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71549       };
71550     } catch (...) {
71551       {
71552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71553       };
71554     }
71555   }
71556
71557 }
71558
71559
71560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71561   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71562   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71563   float arg3 ;
71564
71565   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71566   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71567   if (!arg2) {
71568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71569     return ;
71570   }
71571   arg3 = (float)jarg3;
71572   {
71573     try {
71574       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71575     } catch (std::out_of_range& e) {
71576       {
71577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71578       };
71579     } catch (std::exception& e) {
71580       {
71581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71582       };
71583     } catch (Dali::DaliException e) {
71584       {
71585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71586       };
71587     } catch (...) {
71588       {
71589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71590       };
71591     }
71592   }
71593
71594 }
71595
71596
71597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71598   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71599   Dali::Toolkit::Item arg2 ;
71600   float arg3 ;
71601   Dali::Toolkit::Item *argp2 ;
71602
71603   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71604   argp2 = (Dali::Toolkit::Item *)jarg2;
71605   if (!argp2) {
71606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71607     return ;
71608   }
71609   arg2 = *argp2;
71610   arg3 = (float)jarg3;
71611   {
71612     try {
71613       (arg1)->ReplaceItem(arg2,arg3);
71614     } catch (std::out_of_range& e) {
71615       {
71616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71617       };
71618     } catch (std::exception& e) {
71619       {
71620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71621       };
71622     } catch (Dali::DaliException e) {
71623       {
71624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71625       };
71626     } catch (...) {
71627       {
71628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71629       };
71630     }
71631   }
71632
71633 }
71634
71635
71636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71637   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71638   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71639   float arg3 ;
71640
71641   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71642   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71643   if (!arg2) {
71644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71645     return ;
71646   }
71647   arg3 = (float)jarg3;
71648   {
71649     try {
71650       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71651     } catch (std::out_of_range& e) {
71652       {
71653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71654       };
71655     } catch (std::exception& e) {
71656       {
71657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71658       };
71659     } catch (Dali::DaliException e) {
71660       {
71661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71662       };
71663     } catch (...) {
71664       {
71665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71666       };
71667     }
71668   }
71669
71670 }
71671
71672
71673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71674   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71675   Dali::Vector3 *arg2 = 0 ;
71676
71677   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71678   arg2 = (Dali::Vector3 *)jarg2;
71679   if (!arg2) {
71680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71681     return ;
71682   }
71683   {
71684     try {
71685       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71686     } catch (std::out_of_range& e) {
71687       {
71688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71689       };
71690     } catch (std::exception& e) {
71691       {
71692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71693       };
71694     } catch (Dali::DaliException e) {
71695       {
71696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71697       };
71698     } catch (...) {
71699       {
71700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71701       };
71702     }
71703   }
71704
71705 }
71706
71707
71708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
71709   void * jresult ;
71710   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71711   Dali::Vector3 result;
71712
71713   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71714   {
71715     try {
71716       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71717     } catch (std::out_of_range& e) {
71718       {
71719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71720       };
71721     } catch (std::exception& e) {
71722       {
71723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71724       };
71725     } catch (Dali::DaliException e) {
71726       {
71727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71728       };
71729     } catch (...) {
71730       {
71731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71732       };
71733     }
71734   }
71735
71736   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71737   return jresult;
71738 }
71739
71740
71741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71742   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71743   Dali::Vector3 *arg2 = 0 ;
71744
71745   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71746   arg2 = (Dali::Vector3 *)jarg2;
71747   if (!arg2) {
71748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71749     return ;
71750   }
71751   {
71752     try {
71753       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71754     } catch (std::out_of_range& e) {
71755       {
71756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71757       };
71758     } catch (std::exception& e) {
71759       {
71760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71761       };
71762     } catch (Dali::DaliException e) {
71763       {
71764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71765       };
71766     } catch (...) {
71767       {
71768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71769       };
71770     }
71771   }
71772
71773 }
71774
71775
71776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
71777   void * jresult ;
71778   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71779   Dali::Vector3 result;
71780
71781   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71782   {
71783     try {
71784       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
71785     } catch (std::out_of_range& e) {
71786       {
71787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71788       };
71789     } catch (std::exception& e) {
71790       {
71791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71792       };
71793     } catch (Dali::DaliException e) {
71794       {
71795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71796       };
71797     } catch (...) {
71798       {
71799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71800       };
71801     }
71802   }
71803
71804   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71805   return jresult;
71806 }
71807
71808
71809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
71810   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71811   Dali::Toolkit::ItemRange *arg2 = 0 ;
71812
71813   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71814   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
71815   if (!arg2) {
71816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
71817     return ;
71818   }
71819   {
71820     try {
71821       (arg1)->GetItemsRange(*arg2);
71822     } catch (std::out_of_range& e) {
71823       {
71824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71825       };
71826     } catch (std::exception& e) {
71827       {
71828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71829       };
71830     } catch (Dali::DaliException e) {
71831       {
71832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71833       };
71834     } catch (...) {
71835       {
71836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71837       };
71838     }
71839   }
71840
71841 }
71842
71843
71844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
71845   void * jresult ;
71846   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71847   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
71848
71849   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71850   {
71851     try {
71852       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
71853     } catch (std::out_of_range& e) {
71854       {
71855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71856       };
71857     } catch (std::exception& e) {
71858       {
71859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71860       };
71861     } catch (Dali::DaliException e) {
71862       {
71863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71864       };
71865     } catch (...) {
71866       {
71867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71868       };
71869     }
71870   }
71871
71872   jresult = (void *)result;
71873   return jresult;
71874 }
71875
71876
71877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
71878   Dali::Vector3 *arg1 = 0 ;
71879   PropertyInputContainer *arg2 = 0 ;
71880
71881   arg1 = (Dali::Vector3 *)jarg1;
71882   if (!arg1) {
71883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71884     return ;
71885   }
71886   arg2 = (PropertyInputContainer *)jarg2;
71887   if (!arg2) {
71888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71889     return ;
71890   }
71891   {
71892     try {
71893       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71894     } catch (std::out_of_range& e) {
71895       {
71896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71897       };
71898     } catch (std::exception& e) {
71899       {
71900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71901       };
71902     } catch (Dali::DaliException e) {
71903       {
71904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71905       };
71906     } catch (...) {
71907       {
71908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71909       };
71910     }
71911   }
71912
71913 }
71914
71915
71916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
71917   Dali::Vector3 *arg1 = 0 ;
71918   PropertyInputContainer *arg2 = 0 ;
71919
71920   arg1 = (Dali::Vector3 *)jarg1;
71921   if (!arg1) {
71922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71923     return ;
71924   }
71925   arg2 = (PropertyInputContainer *)jarg2;
71926   if (!arg2) {
71927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71928     return ;
71929   }
71930   {
71931     try {
71932       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71933     } catch (std::out_of_range& e) {
71934       {
71935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71936       };
71937     } catch (std::exception& e) {
71938       {
71939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71940       };
71941     } catch (Dali::DaliException e) {
71942       {
71943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71944       };
71945     } catch (...) {
71946       {
71947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71948       };
71949     }
71950   }
71951
71952 }
71953
71954
71955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
71956   void * jresult ;
71957   Dali::Toolkit::ScrollViewEffect *result = 0 ;
71958
71959   {
71960     try {
71961       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
71962     } catch (std::out_of_range& e) {
71963       {
71964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71965       };
71966     } catch (std::exception& e) {
71967       {
71968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71969       };
71970     } catch (Dali::DaliException e) {
71971       {
71972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71973       };
71974     } catch (...) {
71975       {
71976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71977       };
71978     }
71979   }
71980
71981   jresult = (void *)result;
71982   return jresult;
71983 }
71984
71985
71986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
71987   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
71988
71989   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
71990   {
71991     try {
71992       delete arg1;
71993     } catch (std::out_of_range& e) {
71994       {
71995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71996       };
71997     } catch (std::exception& e) {
71998       {
71999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72000       };
72001     } catch (Dali::DaliException e) {
72002       {
72003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72004       };
72005     } catch (...) {
72006       {
72007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72008       };
72009     }
72010   }
72011
72012 }
72013
72014
72015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72016   void * jresult ;
72017   Dali::Path arg1 ;
72018   Dali::Vector3 *arg2 = 0 ;
72019   Dali::Property::Index arg3 ;
72020   Dali::Vector3 *arg4 = 0 ;
72021   unsigned int arg5 ;
72022   Dali::Path *argp1 ;
72023   Dali::Toolkit::ScrollViewPagePathEffect result;
72024
72025   argp1 = (Dali::Path *)jarg1;
72026   if (!argp1) {
72027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72028     return 0;
72029   }
72030   arg1 = *argp1;
72031   arg2 = (Dali::Vector3 *)jarg2;
72032   if (!arg2) {
72033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72034     return 0;
72035   }
72036   arg3 = (Dali::Property::Index)jarg3;
72037   arg4 = (Dali::Vector3 *)jarg4;
72038   if (!arg4) {
72039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72040     return 0;
72041   }
72042   arg5 = (unsigned int)jarg5;
72043   {
72044     try {
72045       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72046     } catch (std::out_of_range& e) {
72047       {
72048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72049       };
72050     } catch (std::exception& e) {
72051       {
72052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72053       };
72054     } catch (Dali::DaliException e) {
72055       {
72056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72057       };
72058     } catch (...) {
72059       {
72060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72061       };
72062     }
72063   }
72064
72065   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72066   return jresult;
72067 }
72068
72069
72070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72071   void * jresult ;
72072   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72073
72074   {
72075     try {
72076       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72077     } catch (std::out_of_range& e) {
72078       {
72079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72080       };
72081     } catch (std::exception& e) {
72082       {
72083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72084       };
72085     } catch (Dali::DaliException e) {
72086       {
72087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72088       };
72089     } catch (...) {
72090       {
72091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72092       };
72093     }
72094   }
72095
72096   jresult = (void *)result;
72097   return jresult;
72098 }
72099
72100
72101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72102   void * jresult ;
72103   Dali::BaseHandle arg1 ;
72104   Dali::BaseHandle *argp1 ;
72105   Dali::Toolkit::ScrollViewPagePathEffect result;
72106
72107   argp1 = (Dali::BaseHandle *)jarg1;
72108   if (!argp1) {
72109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72110     return 0;
72111   }
72112   arg1 = *argp1;
72113   {
72114     try {
72115       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72116     } catch (std::out_of_range& e) {
72117       {
72118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72119       };
72120     } catch (std::exception& e) {
72121       {
72122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72123       };
72124     } catch (Dali::DaliException e) {
72125       {
72126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72127       };
72128     } catch (...) {
72129       {
72130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72131       };
72132     }
72133   }
72134
72135   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72136   return jresult;
72137 }
72138
72139
72140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72141   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72142   Dali::Actor arg2 ;
72143   unsigned int arg3 ;
72144   Dali::Actor *argp2 ;
72145
72146   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72147   argp2 = (Dali::Actor *)jarg2;
72148   if (!argp2) {
72149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72150     return ;
72151   }
72152   arg2 = *argp2;
72153   arg3 = (unsigned int)jarg3;
72154   {
72155     try {
72156       (arg1)->ApplyToPage(arg2,arg3);
72157     } catch (std::out_of_range& e) {
72158       {
72159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72160       };
72161     } catch (std::exception& e) {
72162       {
72163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72164       };
72165     } catch (Dali::DaliException e) {
72166       {
72167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72168       };
72169     } catch (...) {
72170       {
72171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72172       };
72173     }
72174   }
72175
72176 }
72177
72178
72179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72180   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72181
72182   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72183   {
72184     try {
72185       delete arg1;
72186     } catch (std::out_of_range& e) {
72187       {
72188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72189       };
72190     } catch (std::exception& e) {
72191       {
72192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72193       };
72194     } catch (Dali::DaliException e) {
72195       {
72196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72197       };
72198     } catch (...) {
72199       {
72200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72201       };
72202     }
72203   }
72204
72205 }
72206
72207
72208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
72209   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72210   Dali::Toolkit::ClampState arg2 ;
72211
72212   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72213   arg2 = (Dali::Toolkit::ClampState)jarg2;
72214   if (arg1) (arg1)->x = arg2;
72215 }
72216
72217
72218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
72219   int jresult ;
72220   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72221   Dali::Toolkit::ClampState result;
72222
72223   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72224   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72225   jresult = (int)result;
72226   return jresult;
72227 }
72228
72229
72230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72231   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72232   Dali::Toolkit::ClampState arg2 ;
72233
72234   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72235   arg2 = (Dali::Toolkit::ClampState)jarg2;
72236   if (arg1) (arg1)->y = arg2;
72237 }
72238
72239
72240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72241   int jresult ;
72242   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72243   Dali::Toolkit::ClampState result;
72244
72245   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72246   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72247   jresult = (int)result;
72248   return jresult;
72249 }
72250
72251
72252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72253   void * jresult ;
72254   Dali::Toolkit::ClampState2D *result = 0 ;
72255
72256   {
72257     try {
72258       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72259     } catch (std::out_of_range& e) {
72260       {
72261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72262       };
72263     } catch (std::exception& e) {
72264       {
72265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72266       };
72267     } catch (Dali::DaliException e) {
72268       {
72269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72270       };
72271     } catch (...) {
72272       {
72273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72274       };
72275     }
72276   }
72277
72278   jresult = (void *)result;
72279   return jresult;
72280 }
72281
72282
72283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72284   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72285
72286   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72287   {
72288     try {
72289       delete arg1;
72290     } catch (std::out_of_range& e) {
72291       {
72292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72293       };
72294     } catch (std::exception& e) {
72295       {
72296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72297       };
72298     } catch (Dali::DaliException e) {
72299       {
72300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72301       };
72302     } catch (...) {
72303       {
72304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72305       };
72306     }
72307   }
72308
72309 }
72310
72311
72312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72313   void * jresult ;
72314   float arg1 ;
72315   float arg2 ;
72316   bool arg3 ;
72317   Dali::Toolkit::RulerDomain *result = 0 ;
72318
72319   arg1 = (float)jarg1;
72320   arg2 = (float)jarg2;
72321   arg3 = jarg3 ? true : false;
72322   {
72323     try {
72324       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72325     } catch (std::out_of_range& e) {
72326       {
72327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72328       };
72329     } catch (std::exception& e) {
72330       {
72331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72332       };
72333     } catch (Dali::DaliException e) {
72334       {
72335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72336       };
72337     } catch (...) {
72338       {
72339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72340       };
72341     }
72342   }
72343
72344   jresult = (void *)result;
72345   return jresult;
72346 }
72347
72348
72349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72350   void * jresult ;
72351   float arg1 ;
72352   float arg2 ;
72353   Dali::Toolkit::RulerDomain *result = 0 ;
72354
72355   arg1 = (float)jarg1;
72356   arg2 = (float)jarg2;
72357   {
72358     try {
72359       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72360     } catch (std::out_of_range& e) {
72361       {
72362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72363       };
72364     } catch (std::exception& e) {
72365       {
72366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72367       };
72368     } catch (Dali::DaliException e) {
72369       {
72370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72371       };
72372     } catch (...) {
72373       {
72374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72375       };
72376     }
72377   }
72378
72379   jresult = (void *)result;
72380   return jresult;
72381 }
72382
72383
72384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
72385   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72386   float arg2 ;
72387
72388   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72389   arg2 = (float)jarg2;
72390   if (arg1) (arg1)->min = arg2;
72391 }
72392
72393
72394 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
72395   float jresult ;
72396   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72397   float result;
72398
72399   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72400   result = (float) ((arg1)->min);
72401   jresult = result;
72402   return jresult;
72403 }
72404
72405
72406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72407   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72408   float arg2 ;
72409
72410   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72411   arg2 = (float)jarg2;
72412   if (arg1) (arg1)->max = arg2;
72413 }
72414
72415
72416 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72417   float jresult ;
72418   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72419   float result;
72420
72421   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72422   result = (float) ((arg1)->max);
72423   jresult = result;
72424   return jresult;
72425 }
72426
72427
72428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72429   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72430   bool arg2 ;
72431
72432   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72433   arg2 = jarg2 ? true : false;
72434   if (arg1) (arg1)->enabled = arg2;
72435 }
72436
72437
72438 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72439   unsigned int jresult ;
72440   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72441   bool result;
72442
72443   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72444   result = (bool) ((arg1)->enabled);
72445   jresult = result;
72446   return jresult;
72447 }
72448
72449
72450 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72451   float jresult ;
72452   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72453   float arg2 ;
72454   float arg3 ;
72455   float arg4 ;
72456   float result;
72457
72458   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72459   arg2 = (float)jarg2;
72460   arg3 = (float)jarg3;
72461   arg4 = (float)jarg4;
72462   {
72463     try {
72464       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72465     } catch (std::out_of_range& e) {
72466       {
72467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72468       };
72469     } catch (std::exception& e) {
72470       {
72471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72472       };
72473     } catch (Dali::DaliException e) {
72474       {
72475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72476       };
72477     } catch (...) {
72478       {
72479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72480       };
72481     }
72482   }
72483
72484   jresult = result;
72485   return jresult;
72486 }
72487
72488
72489 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72490   float jresult ;
72491   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72492   float arg2 ;
72493   float arg3 ;
72494   float result;
72495
72496   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72497   arg2 = (float)jarg2;
72498   arg3 = (float)jarg3;
72499   {
72500     try {
72501       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72502     } catch (std::out_of_range& e) {
72503       {
72504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72505       };
72506     } catch (std::exception& e) {
72507       {
72508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72509       };
72510     } catch (Dali::DaliException e) {
72511       {
72512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72513       };
72514     } catch (...) {
72515       {
72516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72517       };
72518     }
72519   }
72520
72521   jresult = result;
72522   return jresult;
72523 }
72524
72525
72526 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72527   float jresult ;
72528   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72529   float arg2 ;
72530   float result;
72531
72532   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72533   arg2 = (float)jarg2;
72534   {
72535     try {
72536       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72537     } catch (std::out_of_range& e) {
72538       {
72539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72540       };
72541     } catch (std::exception& e) {
72542       {
72543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72544       };
72545     } catch (Dali::DaliException e) {
72546       {
72547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72548       };
72549     } catch (...) {
72550       {
72551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72552       };
72553     }
72554   }
72555
72556   jresult = result;
72557   return jresult;
72558 }
72559
72560
72561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72562   float jresult ;
72563   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72564   float arg2 ;
72565   float arg3 ;
72566   float arg4 ;
72567   Dali::Toolkit::ClampState *arg5 = 0 ;
72568   float result;
72569
72570   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72571   arg2 = (float)jarg2;
72572   arg3 = (float)jarg3;
72573   arg4 = (float)jarg4;
72574   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72575   if (!arg5) {
72576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72577     return 0;
72578   }
72579   {
72580     try {
72581       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72582     } catch (std::out_of_range& e) {
72583       {
72584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72585       };
72586     } catch (std::exception& e) {
72587       {
72588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72589       };
72590     } catch (Dali::DaliException e) {
72591       {
72592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72593       };
72594     } catch (...) {
72595       {
72596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72597       };
72598     }
72599   }
72600
72601   jresult = result;
72602   return jresult;
72603 }
72604
72605
72606 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
72607   float jresult ;
72608   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72609   float result;
72610
72611   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72612   {
72613     try {
72614       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72615     } catch (std::out_of_range& e) {
72616       {
72617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72618       };
72619     } catch (std::exception& e) {
72620       {
72621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72622       };
72623     } catch (Dali::DaliException e) {
72624       {
72625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72626       };
72627     } catch (...) {
72628       {
72629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72630       };
72631     }
72632   }
72633
72634   jresult = result;
72635   return jresult;
72636 }
72637
72638
72639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72640   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72641
72642   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72643   {
72644     try {
72645       delete arg1;
72646     } catch (std::out_of_range& e) {
72647       {
72648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72649       };
72650     } catch (std::exception& e) {
72651       {
72652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72653       };
72654     } catch (Dali::DaliException e) {
72655       {
72656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72657       };
72658     } catch (...) {
72659       {
72660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72661       };
72662     }
72663   }
72664
72665 }
72666
72667
72668 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72669   float jresult ;
72670   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72671   float arg2 ;
72672   float arg3 ;
72673   float result;
72674
72675   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72676   arg2 = (float)jarg2;
72677   arg3 = (float)jarg3;
72678   {
72679     try {
72680       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72681     } catch (std::out_of_range& e) {
72682       {
72683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72684       };
72685     } catch (std::exception& e) {
72686       {
72687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72688       };
72689     } catch (Dali::DaliException e) {
72690       {
72691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72692       };
72693     } catch (...) {
72694       {
72695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72696       };
72697     }
72698   }
72699
72700   jresult = result;
72701   return jresult;
72702 }
72703
72704
72705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72706   float jresult ;
72707   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72708   float arg2 ;
72709   float result;
72710
72711   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72712   arg2 = (float)jarg2;
72713   {
72714     try {
72715       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72716     } catch (std::out_of_range& e) {
72717       {
72718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72719       };
72720     } catch (std::exception& e) {
72721       {
72722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72723       };
72724     } catch (Dali::DaliException e) {
72725       {
72726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72727       };
72728     } catch (...) {
72729       {
72730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72731       };
72732     }
72733   }
72734
72735   jresult = result;
72736   return jresult;
72737 }
72738
72739
72740 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72741   float jresult ;
72742   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72743   unsigned int arg2 ;
72744   unsigned int *arg3 = 0 ;
72745   bool arg4 ;
72746   float result;
72747
72748   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72749   arg2 = (unsigned int)jarg2;
72750   arg3 = (unsigned int *)jarg3;
72751   arg4 = jarg4 ? true : false;
72752   {
72753     try {
72754       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
72755     } catch (std::out_of_range& e) {
72756       {
72757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72758       };
72759     } catch (std::exception& e) {
72760       {
72761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72762       };
72763     } catch (Dali::DaliException e) {
72764       {
72765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72766       };
72767     } catch (...) {
72768       {
72769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72770       };
72771     }
72772   }
72773
72774   jresult = result;
72775   return jresult;
72776 }
72777
72778
72779 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72780   unsigned int jresult ;
72781   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72782   float arg2 ;
72783   bool arg3 ;
72784   unsigned int result;
72785
72786   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72787   arg2 = (float)jarg2;
72788   arg3 = jarg3 ? true : false;
72789   {
72790     try {
72791       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72792     } catch (std::out_of_range& e) {
72793       {
72794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72795       };
72796     } catch (std::exception& e) {
72797       {
72798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72799       };
72800     } catch (Dali::DaliException e) {
72801       {
72802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72803       };
72804     } catch (...) {
72805       {
72806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72807       };
72808     }
72809   }
72810
72811   jresult = result;
72812   return jresult;
72813 }
72814
72815
72816 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
72817   unsigned int jresult ;
72818   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72819   unsigned int result;
72820
72821   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72822   {
72823     try {
72824       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
72825     } catch (std::out_of_range& e) {
72826       {
72827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72828       };
72829     } catch (std::exception& e) {
72830       {
72831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72832       };
72833     } catch (Dali::DaliException e) {
72834       {
72835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72836       };
72837     } catch (...) {
72838       {
72839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72840       };
72841     }
72842   }
72843
72844   jresult = result;
72845   return jresult;
72846 }
72847
72848
72849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
72850   int jresult ;
72851   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72852   Dali::Toolkit::Ruler::RulerType result;
72853
72854   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72855   {
72856     try {
72857       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
72858     } catch (std::out_of_range& e) {
72859       {
72860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72861       };
72862     } catch (std::exception& e) {
72863       {
72864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72865       };
72866     } catch (Dali::DaliException e) {
72867       {
72868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72869       };
72870     } catch (...) {
72871       {
72872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72873       };
72874     }
72875   }
72876
72877   jresult = (int)result;
72878   return jresult;
72879 }
72880
72881
72882 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
72883   unsigned int jresult ;
72884   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72885   bool result;
72886
72887   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72888   {
72889     try {
72890       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
72891     } catch (std::out_of_range& e) {
72892       {
72893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72894       };
72895     } catch (std::exception& e) {
72896       {
72897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72898       };
72899     } catch (Dali::DaliException e) {
72900       {
72901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72902       };
72903     } catch (...) {
72904       {
72905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72906       };
72907     }
72908   }
72909
72910   jresult = result;
72911   return jresult;
72912 }
72913
72914
72915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
72916   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72917
72918   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72919   {
72920     try {
72921       (arg1)->Enable();
72922     } catch (std::out_of_range& e) {
72923       {
72924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72925       };
72926     } catch (std::exception& e) {
72927       {
72928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72929       };
72930     } catch (Dali::DaliException e) {
72931       {
72932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72933       };
72934     } catch (...) {
72935       {
72936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72937       };
72938     }
72939   }
72940
72941 }
72942
72943
72944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
72945   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72946
72947   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72948   {
72949     try {
72950       (arg1)->Disable();
72951     } catch (std::out_of_range& e) {
72952       {
72953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72954       };
72955     } catch (std::exception& e) {
72956       {
72957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72958       };
72959     } catch (Dali::DaliException e) {
72960       {
72961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72962       };
72963     } catch (...) {
72964       {
72965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72966       };
72967     }
72968   }
72969
72970 }
72971
72972
72973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
72974   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72975   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
72976   Dali::Toolkit::RulerDomain *argp2 ;
72977
72978   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72979   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
72980   if (!argp2) {
72981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
72982     return ;
72983   }
72984   arg2 = *argp2;
72985   {
72986     try {
72987       (arg1)->SetDomain(arg2);
72988     } catch (std::out_of_range& e) {
72989       {
72990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72991       };
72992     } catch (std::exception& e) {
72993       {
72994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72995       };
72996     } catch (Dali::DaliException e) {
72997       {
72998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72999       };
73000     } catch (...) {
73001       {
73002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73003       };
73004     }
73005   }
73006
73007 }
73008
73009
73010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
73011   void * jresult ;
73012   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73013   Dali::Toolkit::RulerDomain *result = 0 ;
73014
73015   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73016   {
73017     try {
73018       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
73019     } catch (std::out_of_range& e) {
73020       {
73021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73022       };
73023     } catch (std::exception& e) {
73024       {
73025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73026       };
73027     } catch (Dali::DaliException e) {
73028       {
73029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73030       };
73031     } catch (...) {
73032       {
73033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73034       };
73035     }
73036   }
73037
73038   jresult = (void *)result;
73039   return jresult;
73040 }
73041
73042
73043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
73044   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73045
73046   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73047   {
73048     try {
73049       (arg1)->DisableDomain();
73050     } catch (std::out_of_range& e) {
73051       {
73052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73053       };
73054     } catch (std::exception& e) {
73055       {
73056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73057       };
73058     } catch (Dali::DaliException e) {
73059       {
73060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73061       };
73062     } catch (...) {
73063       {
73064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73065       };
73066     }
73067   }
73068
73069 }
73070
73071
73072 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
73073   float jresult ;
73074   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73075   float arg2 ;
73076   float arg3 ;
73077   float arg4 ;
73078   float result;
73079
73080   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73081   arg2 = (float)jarg2;
73082   arg3 = (float)jarg3;
73083   arg4 = (float)jarg4;
73084   {
73085     try {
73086       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
73087     } catch (std::out_of_range& e) {
73088       {
73089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73090       };
73091     } catch (std::exception& e) {
73092       {
73093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73094       };
73095     } catch (Dali::DaliException e) {
73096       {
73097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73098       };
73099     } catch (...) {
73100       {
73101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73102       };
73103     }
73104   }
73105
73106   jresult = result;
73107   return jresult;
73108 }
73109
73110
73111 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73112   float jresult ;
73113   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73114   float arg2 ;
73115   float arg3 ;
73116   float result;
73117
73118   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73119   arg2 = (float)jarg2;
73120   arg3 = (float)jarg3;
73121   {
73122     try {
73123       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73124     } catch (std::out_of_range& e) {
73125       {
73126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73127       };
73128     } catch (std::exception& e) {
73129       {
73130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73131       };
73132     } catch (Dali::DaliException e) {
73133       {
73134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73135       };
73136     } catch (...) {
73137       {
73138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73139       };
73140     }
73141   }
73142
73143   jresult = result;
73144   return jresult;
73145 }
73146
73147
73148 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73149   float jresult ;
73150   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73151   float arg2 ;
73152   float result;
73153
73154   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73155   arg2 = (float)jarg2;
73156   {
73157     try {
73158       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73159     } catch (std::out_of_range& e) {
73160       {
73161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73162       };
73163     } catch (std::exception& e) {
73164       {
73165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73166       };
73167     } catch (Dali::DaliException e) {
73168       {
73169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73170       };
73171     } catch (...) {
73172       {
73173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73174       };
73175     }
73176   }
73177
73178   jresult = result;
73179   return jresult;
73180 }
73181
73182
73183 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73184   float jresult ;
73185   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73186   float arg2 ;
73187   float arg3 ;
73188   float arg4 ;
73189   Dali::Toolkit::ClampState *arg5 = 0 ;
73190   float result;
73191
73192   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73193   arg2 = (float)jarg2;
73194   arg3 = (float)jarg3;
73195   arg4 = (float)jarg4;
73196   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73197   if (!arg5) {
73198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73199     return 0;
73200   }
73201   {
73202     try {
73203       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73204     } catch (std::out_of_range& e) {
73205       {
73206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73207       };
73208     } catch (std::exception& e) {
73209       {
73210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73211       };
73212     } catch (Dali::DaliException e) {
73213       {
73214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73215       };
73216     } catch (...) {
73217       {
73218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73219       };
73220     }
73221   }
73222
73223   jresult = result;
73224   return jresult;
73225 }
73226
73227
73228 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73229   float jresult ;
73230   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73231   float arg2 ;
73232   float arg3 ;
73233   float arg4 ;
73234   float arg5 ;
73235   float result;
73236
73237   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73238   arg2 = (float)jarg2;
73239   arg3 = (float)jarg3;
73240   arg4 = (float)jarg4;
73241   arg5 = (float)jarg5;
73242   {
73243     try {
73244       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73245     } catch (std::out_of_range& e) {
73246       {
73247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73248       };
73249     } catch (std::exception& e) {
73250       {
73251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73252       };
73253     } catch (Dali::DaliException e) {
73254       {
73255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73256       };
73257     } catch (...) {
73258       {
73259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73260       };
73261     }
73262   }
73263
73264   jresult = result;
73265   return jresult;
73266 }
73267
73268
73269 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73270   float jresult ;
73271   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73272   float arg2 ;
73273   float arg3 ;
73274   float arg4 ;
73275   float result;
73276
73277   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73278   arg2 = (float)jarg2;
73279   arg3 = (float)jarg3;
73280   arg4 = (float)jarg4;
73281   {
73282     try {
73283       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
73284     } catch (std::out_of_range& e) {
73285       {
73286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73287       };
73288     } catch (std::exception& e) {
73289       {
73290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73291       };
73292     } catch (Dali::DaliException e) {
73293       {
73294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73295       };
73296     } catch (...) {
73297       {
73298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73299       };
73300     }
73301   }
73302
73303   jresult = result;
73304   return jresult;
73305 }
73306
73307
73308 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73309   float jresult ;
73310   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73311   float arg2 ;
73312   float arg3 ;
73313   float result;
73314
73315   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73316   arg2 = (float)jarg2;
73317   arg3 = (float)jarg3;
73318   {
73319     try {
73320       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
73321     } catch (std::out_of_range& e) {
73322       {
73323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73324       };
73325     } catch (std::exception& e) {
73326       {
73327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73328       };
73329     } catch (Dali::DaliException e) {
73330       {
73331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73332       };
73333     } catch (...) {
73334       {
73335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73336       };
73337     }
73338   }
73339
73340   jresult = result;
73341   return jresult;
73342 }
73343
73344
73345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73346   float jresult ;
73347   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73348   float arg2 ;
73349   float result;
73350
73351   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73352   arg2 = (float)jarg2;
73353   {
73354     try {
73355       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73356     } catch (std::out_of_range& e) {
73357       {
73358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73359       };
73360     } catch (std::exception& e) {
73361       {
73362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73363       };
73364     } catch (Dali::DaliException e) {
73365       {
73366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73367       };
73368     } catch (...) {
73369       {
73370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73371       };
73372     }
73373   }
73374
73375   jresult = result;
73376   return jresult;
73377 }
73378
73379
73380 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73381   float jresult ;
73382   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73383   float arg2 ;
73384   float arg3 ;
73385   float arg4 ;
73386   float arg5 ;
73387   Dali::Toolkit::ClampState *arg6 = 0 ;
73388   float result;
73389
73390   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73391   arg2 = (float)jarg2;
73392   arg3 = (float)jarg3;
73393   arg4 = (float)jarg4;
73394   arg5 = (float)jarg5;
73395   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73396   if (!arg6) {
73397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73398     return 0;
73399   }
73400   {
73401     try {
73402       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73403     } catch (std::out_of_range& e) {
73404       {
73405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73406       };
73407     } catch (std::exception& e) {
73408       {
73409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73410       };
73411     } catch (Dali::DaliException e) {
73412       {
73413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73414       };
73415     } catch (...) {
73416       {
73417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73418       };
73419     }
73420   }
73421
73422   jresult = result;
73423   return jresult;
73424 }
73425
73426
73427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73428   void * jresult ;
73429   Dali::Toolkit::DefaultRuler *result = 0 ;
73430
73431   {
73432     try {
73433       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73434     } catch (std::out_of_range& e) {
73435       {
73436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73437       };
73438     } catch (std::exception& e) {
73439       {
73440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73441       };
73442     } catch (Dali::DaliException e) {
73443       {
73444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73445       };
73446     } catch (...) {
73447       {
73448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73449       };
73450     }
73451   }
73452
73453   jresult = (void *)result;
73454   return jresult;
73455 }
73456
73457
73458 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73459   float jresult ;
73460   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73461   float arg2 ;
73462   float arg3 ;
73463   float result;
73464
73465   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73466   arg2 = (float)jarg2;
73467   arg3 = (float)jarg3;
73468   {
73469     try {
73470       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73471     } catch (std::out_of_range& e) {
73472       {
73473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73474       };
73475     } catch (std::exception& e) {
73476       {
73477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73478       };
73479     } catch (Dali::DaliException e) {
73480       {
73481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73482       };
73483     } catch (...) {
73484       {
73485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73486       };
73487     }
73488   }
73489
73490   jresult = result;
73491   return jresult;
73492 }
73493
73494
73495 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73496   float jresult ;
73497   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73498   unsigned int arg2 ;
73499   unsigned int *arg3 = 0 ;
73500   bool arg4 ;
73501   float result;
73502
73503   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73504   arg2 = (unsigned int)jarg2;
73505   arg3 = (unsigned int *)jarg3;
73506   arg4 = jarg4 ? true : false;
73507   {
73508     try {
73509       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73510     } catch (std::out_of_range& e) {
73511       {
73512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73513       };
73514     } catch (std::exception& e) {
73515       {
73516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73517       };
73518     } catch (Dali::DaliException e) {
73519       {
73520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73521       };
73522     } catch (...) {
73523       {
73524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73525       };
73526     }
73527   }
73528
73529   jresult = result;
73530   return jresult;
73531 }
73532
73533
73534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73535   unsigned int jresult ;
73536   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73537   float arg2 ;
73538   bool arg3 ;
73539   unsigned int result;
73540
73541   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73542   arg2 = (float)jarg2;
73543   arg3 = jarg3 ? true : false;
73544   {
73545     try {
73546       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73547     } catch (std::out_of_range& e) {
73548       {
73549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73550       };
73551     } catch (std::exception& e) {
73552       {
73553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73554       };
73555     } catch (Dali::DaliException e) {
73556       {
73557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73558       };
73559     } catch (...) {
73560       {
73561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73562       };
73563     }
73564   }
73565
73566   jresult = result;
73567   return jresult;
73568 }
73569
73570
73571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73572   unsigned int jresult ;
73573   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73574   unsigned int result;
73575
73576   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73577   {
73578     try {
73579       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73580     } catch (std::out_of_range& e) {
73581       {
73582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73583       };
73584     } catch (std::exception& e) {
73585       {
73586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73587       };
73588     } catch (Dali::DaliException e) {
73589       {
73590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73591       };
73592     } catch (...) {
73593       {
73594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73595       };
73596     }
73597   }
73598
73599   jresult = result;
73600   return jresult;
73601 }
73602
73603
73604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73605   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73606
73607   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73608   {
73609     try {
73610       delete arg1;
73611     } catch (std::out_of_range& e) {
73612       {
73613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73614       };
73615     } catch (std::exception& e) {
73616       {
73617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73618       };
73619     } catch (Dali::DaliException e) {
73620       {
73621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73622       };
73623     } catch (...) {
73624       {
73625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73626       };
73627     }
73628   }
73629
73630 }
73631
73632
73633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73634   void * jresult ;
73635   float arg1 ;
73636   Dali::Toolkit::FixedRuler *result = 0 ;
73637
73638   arg1 = (float)jarg1;
73639   {
73640     try {
73641       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73642     } catch (std::out_of_range& e) {
73643       {
73644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73645       };
73646     } catch (std::exception& e) {
73647       {
73648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73649       };
73650     } catch (Dali::DaliException e) {
73651       {
73652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73653       };
73654     } catch (...) {
73655       {
73656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73657       };
73658     }
73659   }
73660
73661   jresult = (void *)result;
73662   return jresult;
73663 }
73664
73665
73666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
73667   void * jresult ;
73668   Dali::Toolkit::FixedRuler *result = 0 ;
73669
73670   {
73671     try {
73672       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
73673     } catch (std::out_of_range& e) {
73674       {
73675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73676       };
73677     } catch (std::exception& e) {
73678       {
73679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73680       };
73681     } catch (Dali::DaliException e) {
73682       {
73683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73684       };
73685     } catch (...) {
73686       {
73687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73688       };
73689     }
73690   }
73691
73692   jresult = (void *)result;
73693   return jresult;
73694 }
73695
73696
73697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73698   float jresult ;
73699   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73700   float arg2 ;
73701   float arg3 ;
73702   float result;
73703
73704   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73705   arg2 = (float)jarg2;
73706   arg3 = (float)jarg3;
73707   {
73708     try {
73709       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73710     } catch (std::out_of_range& e) {
73711       {
73712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73713       };
73714     } catch (std::exception& e) {
73715       {
73716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73717       };
73718     } catch (Dali::DaliException e) {
73719       {
73720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73721       };
73722     } catch (...) {
73723       {
73724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73725       };
73726     }
73727   }
73728
73729   jresult = result;
73730   return jresult;
73731 }
73732
73733
73734 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73735   float jresult ;
73736   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73737   unsigned int arg2 ;
73738   unsigned int *arg3 = 0 ;
73739   bool arg4 ;
73740   float result;
73741
73742   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73743   arg2 = (unsigned int)jarg2;
73744   arg3 = (unsigned int *)jarg3;
73745   arg4 = jarg4 ? true : false;
73746   {
73747     try {
73748       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73749     } catch (std::out_of_range& e) {
73750       {
73751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73752       };
73753     } catch (std::exception& e) {
73754       {
73755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73756       };
73757     } catch (Dali::DaliException e) {
73758       {
73759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73760       };
73761     } catch (...) {
73762       {
73763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73764       };
73765     }
73766   }
73767
73768   jresult = result;
73769   return jresult;
73770 }
73771
73772
73773 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73774   unsigned int jresult ;
73775   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73776   float arg2 ;
73777   bool arg3 ;
73778   unsigned int result;
73779
73780   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73781   arg2 = (float)jarg2;
73782   arg3 = jarg3 ? true : false;
73783   {
73784     try {
73785       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73786     } catch (std::out_of_range& e) {
73787       {
73788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73789       };
73790     } catch (std::exception& e) {
73791       {
73792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73793       };
73794     } catch (Dali::DaliException e) {
73795       {
73796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73797       };
73798     } catch (...) {
73799       {
73800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73801       };
73802     }
73803   }
73804
73805   jresult = result;
73806   return jresult;
73807 }
73808
73809
73810 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
73811   unsigned int jresult ;
73812   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73813   unsigned int result;
73814
73815   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73816   {
73817     try {
73818       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
73819     } catch (std::out_of_range& e) {
73820       {
73821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73822       };
73823     } catch (std::exception& e) {
73824       {
73825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73826       };
73827     } catch (Dali::DaliException e) {
73828       {
73829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73830       };
73831     } catch (...) {
73832       {
73833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73834       };
73835     }
73836   }
73837
73838   jresult = result;
73839   return jresult;
73840 }
73841
73842
73843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
73844   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73845
73846   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73847   {
73848     try {
73849       delete arg1;
73850     } catch (std::out_of_range& e) {
73851       {
73852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73853       };
73854     } catch (std::exception& e) {
73855       {
73856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73857       };
73858     } catch (Dali::DaliException e) {
73859       {
73860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73861       };
73862     } catch (...) {
73863       {
73864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73865       };
73866     }
73867   }
73868
73869 }
73870
73871
73872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
73873   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73874   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73875
73876   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73877   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73878   if (arg1) (arg1)->scale = *arg2;
73879 }
73880
73881
73882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
73883   void * jresult ;
73884   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73885   Dali::Toolkit::ClampState2D *result = 0 ;
73886
73887   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73888   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
73889   jresult = (void *)result;
73890   return jresult;
73891 }
73892
73893
73894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
73895   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73896   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73897
73898   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73899   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73900   if (arg1) (arg1)->position = *arg2;
73901 }
73902
73903
73904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
73905   void * jresult ;
73906   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73907   Dali::Toolkit::ClampState2D *result = 0 ;
73908
73909   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73910   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
73911   jresult = (void *)result;
73912   return jresult;
73913 }
73914
73915
73916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
73917   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73918   Dali::Toolkit::ClampState arg2 ;
73919
73920   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73921   arg2 = (Dali::Toolkit::ClampState)jarg2;
73922   if (arg1) (arg1)->rotation = arg2;
73923 }
73924
73925
73926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
73927   int jresult ;
73928   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73929   Dali::Toolkit::ClampState result;
73930
73931   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73932   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
73933   jresult = (int)result;
73934   return jresult;
73935 }
73936
73937
73938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
73939   void * jresult ;
73940   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
73941
73942   {
73943     try {
73944       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
73945     } catch (std::out_of_range& e) {
73946       {
73947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73948       };
73949     } catch (std::exception& e) {
73950       {
73951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73952       };
73953     } catch (Dali::DaliException e) {
73954       {
73955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73956       };
73957     } catch (...) {
73958       {
73959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73960       };
73961     }
73962   }
73963
73964   jresult = (void *)result;
73965   return jresult;
73966 }
73967
73968
73969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
73970   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73971
73972   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73973   {
73974     try {
73975       delete arg1;
73976     } catch (std::out_of_range& e) {
73977       {
73978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73979       };
73980     } catch (std::exception& e) {
73981       {
73982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73983       };
73984     } catch (Dali::DaliException e) {
73985       {
73986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73987       };
73988     } catch (...) {
73989       {
73990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73991       };
73992     }
73993   }
73994
73995 }
73996
73997
73998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
73999   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74000   Dali::Toolkit::SnapType arg2 ;
74001
74002   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74003   arg2 = (Dali::Toolkit::SnapType)jarg2;
74004   if (arg1) (arg1)->type = arg2;
74005 }
74006
74007
74008 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
74009   int jresult ;
74010   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74011   Dali::Toolkit::SnapType result;
74012
74013   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74014   result = (Dali::Toolkit::SnapType) ((arg1)->type);
74015   jresult = (int)result;
74016   return jresult;
74017 }
74018
74019
74020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
74021   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74022   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
74023
74024   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74025   arg2 = (Dali::Vector2 *)jarg2;
74026   if (arg1) (arg1)->position = *arg2;
74027 }
74028
74029
74030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
74031   void * jresult ;
74032   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74033   Dali::Vector2 *result = 0 ;
74034
74035   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74036   result = (Dali::Vector2 *)& ((arg1)->position);
74037   jresult = (void *)result;
74038   return jresult;
74039 }
74040
74041
74042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
74043   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74044   float arg2 ;
74045
74046   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74047   arg2 = (float)jarg2;
74048   if (arg1) (arg1)->duration = arg2;
74049 }
74050
74051
74052 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
74053   float jresult ;
74054   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74055   float result;
74056
74057   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74058   result = (float) ((arg1)->duration);
74059   jresult = result;
74060   return jresult;
74061 }
74062
74063
74064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
74065   void * jresult ;
74066   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
74067
74068   {
74069     try {
74070       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
74071     } catch (std::out_of_range& e) {
74072       {
74073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74074       };
74075     } catch (std::exception& e) {
74076       {
74077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74078       };
74079     } catch (Dali::DaliException e) {
74080       {
74081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74082       };
74083     } catch (...) {
74084       {
74085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74086       };
74087     }
74088   }
74089
74090   jresult = (void *)result;
74091   return jresult;
74092 }
74093
74094
74095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
74096   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74097
74098   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74099   {
74100     try {
74101       delete arg1;
74102     } catch (std::out_of_range& e) {
74103       {
74104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74105       };
74106     } catch (std::exception& e) {
74107       {
74108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74109       };
74110     } catch (Dali::DaliException e) {
74111       {
74112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74113       };
74114     } catch (...) {
74115       {
74116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74117       };
74118     }
74119   }
74120
74121 }
74122
74123
74124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
74125   int jresult ;
74126   int result;
74127
74128   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
74129   jresult = (int)result;
74130   return jresult;
74131 }
74132
74133
74134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
74135   int jresult ;
74136   int result;
74137
74138   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
74139   jresult = (int)result;
74140   return jresult;
74141 }
74142
74143
74144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
74145   int jresult ;
74146   int result;
74147
74148   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
74149   jresult = (int)result;
74150   return jresult;
74151 }
74152
74153
74154 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74155   int jresult ;
74156   int result;
74157
74158   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74159   jresult = (int)result;
74160   return jresult;
74161 }
74162
74163
74164 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
74165   int jresult ;
74166   int result;
74167
74168   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
74169   jresult = (int)result;
74170   return jresult;
74171 }
74172
74173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
74174   int jresult ;
74175   int result;
74176
74177   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
74178   jresult = (int)result;
74179   return jresult;
74180 }
74181
74182
74183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
74184   int jresult ;
74185   int result;
74186
74187   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
74188   jresult = (int)result;
74189   return jresult;
74190 }
74191
74192
74193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
74194   int jresult ;
74195   int result;
74196
74197   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
74198   jresult = (int)result;
74199   return jresult;
74200 }
74201
74202
74203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
74204   int jresult ;
74205   int result;
74206
74207   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
74208   jresult = (int)result;
74209   return jresult;
74210 }
74211
74212
74213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74214   int jresult ;
74215   int result;
74216
74217   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74218   jresult = (int)result;
74219   return jresult;
74220 }
74221
74222
74223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74224   int jresult ;
74225   int result;
74226
74227   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74228   jresult = (int)result;
74229   return jresult;
74230 }
74231
74232
74233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74234   int jresult ;
74235   int result;
74236
74237   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74238   jresult = (int)result;
74239   return jresult;
74240 }
74241
74242
74243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74244   int jresult ;
74245   int result;
74246
74247   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74248   jresult = (int)result;
74249   return jresult;
74250 }
74251
74252
74253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74254   int jresult ;
74255   int result;
74256
74257   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74258   jresult = (int)result;
74259   return jresult;
74260 }
74261
74262
74263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74264   int jresult ;
74265   int result;
74266
74267   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74268   jresult = (int)result;
74269   return jresult;
74270 }
74271
74272
74273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74274   int jresult ;
74275   int result;
74276
74277   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74278   jresult = (int)result;
74279   return jresult;
74280 }
74281
74282
74283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74284   int jresult ;
74285   int result;
74286
74287   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74288   jresult = (int)result;
74289   return jresult;
74290 }
74291
74292
74293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74294   int jresult ;
74295   int result;
74296
74297   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74298   jresult = (int)result;
74299   return jresult;
74300 }
74301
74302
74303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74304   int jresult ;
74305   int result;
74306
74307   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74308   jresult = (int)result;
74309   return jresult;
74310 }
74311
74312
74313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74314   int jresult ;
74315   int result;
74316
74317   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74318   jresult = (int)result;
74319   return jresult;
74320 }
74321
74322
74323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74324   int jresult ;
74325   int result;
74326
74327   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74328   jresult = (int)result;
74329   return jresult;
74330 }
74331
74332
74333 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74334   int jresult ;
74335   int result;
74336
74337   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74338   jresult = (int)result;
74339   return jresult;
74340 }
74341
74342
74343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74344   int jresult ;
74345   int result;
74346
74347   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74348   jresult = (int)result;
74349   return jresult;
74350 }
74351
74352
74353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74354   int jresult ;
74355   int result;
74356
74357   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74358   jresult = (int)result;
74359   return jresult;
74360 }
74361
74362
74363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74364   int jresult ;
74365   int result;
74366
74367   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74368   jresult = (int)result;
74369   return jresult;
74370 }
74371
74372
74373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74374   int jresult ;
74375   int result;
74376
74377   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74378   jresult = (int)result;
74379   return jresult;
74380 }
74381
74382
74383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74384   void * jresult ;
74385   Dali::Toolkit::ScrollView::Property *result = 0 ;
74386
74387   {
74388     try {
74389       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74390     } catch (std::out_of_range& e) {
74391       {
74392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74393       };
74394     } catch (std::exception& e) {
74395       {
74396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74397       };
74398     } catch (Dali::DaliException e) {
74399       {
74400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74401       };
74402     } catch (...) {
74403       {
74404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74405       };
74406     }
74407   }
74408
74409   jresult = (void *)result;
74410   return jresult;
74411 }
74412
74413
74414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74415   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74416
74417   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74418   {
74419     try {
74420       delete arg1;
74421     } catch (std::out_of_range& e) {
74422       {
74423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74424       };
74425     } catch (std::exception& e) {
74426       {
74427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74428       };
74429     } catch (Dali::DaliException e) {
74430       {
74431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74432       };
74433     } catch (...) {
74434       {
74435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74436       };
74437     }
74438   }
74439
74440 }
74441
74442
74443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74444   void * jresult ;
74445   Dali::Toolkit::ScrollView *result = 0 ;
74446
74447   {
74448     try {
74449       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74450     } catch (std::out_of_range& e) {
74451       {
74452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74453       };
74454     } catch (std::exception& e) {
74455       {
74456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74457       };
74458     } catch (Dali::DaliException e) {
74459       {
74460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74461       };
74462     } catch (...) {
74463       {
74464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74465       };
74466     }
74467   }
74468
74469   jresult = (void *)result;
74470   return jresult;
74471 }
74472
74473
74474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74475   void * jresult ;
74476   Dali::Toolkit::ScrollView *arg1 = 0 ;
74477   Dali::Toolkit::ScrollView *result = 0 ;
74478
74479   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74480   if (!arg1) {
74481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74482     return 0;
74483   }
74484   {
74485     try {
74486       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74487     } catch (std::out_of_range& e) {
74488       {
74489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74490       };
74491     } catch (std::exception& e) {
74492       {
74493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74494       };
74495     } catch (Dali::DaliException e) {
74496       {
74497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74498       };
74499     } catch (...) {
74500       {
74501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74502       };
74503     }
74504   }
74505
74506   jresult = (void *)result;
74507   return jresult;
74508 }
74509
74510
74511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74512   void * jresult ;
74513   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74514   Dali::Toolkit::ScrollView *arg2 = 0 ;
74515   Dali::Toolkit::ScrollView *result = 0 ;
74516
74517   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74518   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74519   if (!arg2) {
74520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74521     return 0;
74522   }
74523   {
74524     try {
74525       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74526     } catch (std::out_of_range& e) {
74527       {
74528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74529       };
74530     } catch (std::exception& e) {
74531       {
74532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74533       };
74534     } catch (Dali::DaliException e) {
74535       {
74536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74537       };
74538     } catch (...) {
74539       {
74540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74541       };
74542     }
74543   }
74544
74545   jresult = (void *)result;
74546   return jresult;
74547 }
74548
74549
74550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74551   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74552
74553   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74554   {
74555     try {
74556       delete arg1;
74557     } catch (std::out_of_range& e) {
74558       {
74559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74560       };
74561     } catch (std::exception& e) {
74562       {
74563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74564       };
74565     } catch (Dali::DaliException e) {
74566       {
74567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74568       };
74569     } catch (...) {
74570       {
74571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74572       };
74573     }
74574   }
74575
74576 }
74577
74578
74579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74580   void * jresult ;
74581   Dali::Toolkit::ScrollView result;
74582
74583   {
74584     try {
74585       result = Dali::Toolkit::ScrollView::New();
74586     } catch (std::out_of_range& e) {
74587       {
74588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74589       };
74590     } catch (std::exception& e) {
74591       {
74592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74593       };
74594     } catch (Dali::DaliException e) {
74595       {
74596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74597       };
74598     } catch (...) {
74599       {
74600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74601       };
74602     }
74603   }
74604
74605   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74606   return jresult;
74607 }
74608
74609
74610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74611   void * jresult ;
74612   Dali::BaseHandle arg1 ;
74613   Dali::BaseHandle *argp1 ;
74614   Dali::Toolkit::ScrollView result;
74615
74616   argp1 = (Dali::BaseHandle *)jarg1;
74617   if (!argp1) {
74618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74619     return 0;
74620   }
74621   arg1 = *argp1;
74622   {
74623     try {
74624       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74625     } catch (std::out_of_range& e) {
74626       {
74627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74628       };
74629     } catch (std::exception& e) {
74630       {
74631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74632       };
74633     } catch (Dali::DaliException e) {
74634       {
74635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74636       };
74637     } catch (...) {
74638       {
74639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74640       };
74641     }
74642   }
74643
74644   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74645   return jresult;
74646 }
74647
74648
74649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74650   void * jresult ;
74651   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74652   Dali::AlphaFunction result;
74653
74654   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74655   {
74656     try {
74657       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74658     } catch (std::out_of_range& e) {
74659       {
74660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74661       };
74662     } catch (std::exception& e) {
74663       {
74664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74665       };
74666     } catch (Dali::DaliException e) {
74667       {
74668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74669       };
74670     } catch (...) {
74671       {
74672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74673       };
74674     }
74675   }
74676
74677   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74678   return jresult;
74679 }
74680
74681
74682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74683   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74684   Dali::AlphaFunction arg2 ;
74685   Dali::AlphaFunction *argp2 ;
74686
74687   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74688   argp2 = (Dali::AlphaFunction *)jarg2;
74689   if (!argp2) {
74690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74691     return ;
74692   }
74693   arg2 = *argp2;
74694   {
74695     try {
74696       (arg1)->SetScrollSnapAlphaFunction(arg2);
74697     } catch (std::out_of_range& e) {
74698       {
74699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74700       };
74701     } catch (std::exception& e) {
74702       {
74703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74704       };
74705     } catch (Dali::DaliException e) {
74706       {
74707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74708       };
74709     } catch (...) {
74710       {
74711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74712       };
74713     }
74714   }
74715
74716 }
74717
74718
74719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74720   void * jresult ;
74721   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74722   Dali::AlphaFunction result;
74723
74724   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74725   {
74726     try {
74727       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
74728     } catch (std::out_of_range& e) {
74729       {
74730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74731       };
74732     } catch (std::exception& e) {
74733       {
74734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74735       };
74736     } catch (Dali::DaliException e) {
74737       {
74738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74739       };
74740     } catch (...) {
74741       {
74742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74743       };
74744     }
74745   }
74746
74747   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74748   return jresult;
74749 }
74750
74751
74752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74753   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74754   Dali::AlphaFunction arg2 ;
74755   Dali::AlphaFunction *argp2 ;
74756
74757   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74758   argp2 = (Dali::AlphaFunction *)jarg2;
74759   if (!argp2) {
74760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74761     return ;
74762   }
74763   arg2 = *argp2;
74764   {
74765     try {
74766       (arg1)->SetScrollFlickAlphaFunction(arg2);
74767     } catch (std::out_of_range& e) {
74768       {
74769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74770       };
74771     } catch (std::exception& e) {
74772       {
74773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74774       };
74775     } catch (Dali::DaliException e) {
74776       {
74777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74778       };
74779     } catch (...) {
74780       {
74781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74782       };
74783     }
74784   }
74785
74786 }
74787
74788
74789 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
74790   float jresult ;
74791   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74792   float result;
74793
74794   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74795   {
74796     try {
74797       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
74798     } catch (std::out_of_range& e) {
74799       {
74800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74801       };
74802     } catch (std::exception& e) {
74803       {
74804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74805       };
74806     } catch (Dali::DaliException e) {
74807       {
74808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74809       };
74810     } catch (...) {
74811       {
74812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74813       };
74814     }
74815   }
74816
74817   jresult = result;
74818   return jresult;
74819 }
74820
74821
74822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
74823   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74824   float arg2 ;
74825
74826   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74827   arg2 = (float)jarg2;
74828   {
74829     try {
74830       (arg1)->SetScrollSnapDuration(arg2);
74831     } catch (std::out_of_range& e) {
74832       {
74833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74834       };
74835     } catch (std::exception& e) {
74836       {
74837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74838       };
74839     } catch (Dali::DaliException e) {
74840       {
74841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74842       };
74843     } catch (...) {
74844       {
74845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74846       };
74847     }
74848   }
74849
74850 }
74851
74852
74853 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
74854   float jresult ;
74855   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74856   float result;
74857
74858   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74859   {
74860     try {
74861       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
74862     } catch (std::out_of_range& e) {
74863       {
74864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74865       };
74866     } catch (std::exception& e) {
74867       {
74868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74869       };
74870     } catch (Dali::DaliException e) {
74871       {
74872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74873       };
74874     } catch (...) {
74875       {
74876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74877       };
74878     }
74879   }
74880
74881   jresult = result;
74882   return jresult;
74883 }
74884
74885
74886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
74887   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74888   float arg2 ;
74889
74890   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74891   arg2 = (float)jarg2;
74892   {
74893     try {
74894       (arg1)->SetScrollFlickDuration(arg2);
74895     } catch (std::out_of_range& e) {
74896       {
74897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74898       };
74899     } catch (std::exception& e) {
74900       {
74901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74902       };
74903     } catch (Dali::DaliException e) {
74904       {
74905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74906       };
74907     } catch (...) {
74908       {
74909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74910       };
74911     }
74912   }
74913
74914 }
74915
74916
74917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
74918   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74919   Dali::Toolkit::RulerPtr arg2 ;
74920   Dali::Toolkit::RulerPtr *argp2 ;
74921
74922   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74923   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74924   if (!argp2) {
74925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74926     return ;
74927   }
74928   arg2 = *argp2;
74929   {
74930     try {
74931       (arg1)->SetRulerX(arg2);
74932     } catch (std::out_of_range& e) {
74933       {
74934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74935       };
74936     } catch (std::exception& e) {
74937       {
74938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74939       };
74940     } catch (Dali::DaliException e) {
74941       {
74942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74943       };
74944     } catch (...) {
74945       {
74946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74947       };
74948     }
74949   }
74950
74951 }
74952
74953
74954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
74955   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74956   Dali::Toolkit::RulerPtr arg2 ;
74957   Dali::Toolkit::RulerPtr *argp2 ;
74958
74959   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74960   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74961   if (!argp2) {
74962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74963     return ;
74964   }
74965   arg2 = *argp2;
74966   {
74967     try {
74968       (arg1)->SetRulerY(arg2);
74969     } catch (std::out_of_range& e) {
74970       {
74971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74972       };
74973     } catch (std::exception& e) {
74974       {
74975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74976       };
74977     } catch (Dali::DaliException e) {
74978       {
74979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74980       };
74981     } catch (...) {
74982       {
74983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74984       };
74985     }
74986   }
74987
74988 }
74989
74990
74991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
74992   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74993   bool arg2 ;
74994
74995   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74996   arg2 = jarg2 ? true : false;
74997   {
74998     try {
74999       (arg1)->SetScrollSensitive(arg2);
75000     } catch (std::out_of_range& e) {
75001       {
75002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75003       };
75004     } catch (std::exception& e) {
75005       {
75006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75007       };
75008     } catch (Dali::DaliException e) {
75009       {
75010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75011       };
75012     } catch (...) {
75013       {
75014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75015       };
75016     }
75017   }
75018
75019 }
75020
75021
75022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
75023   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75024   float arg2 ;
75025   float arg3 ;
75026
75027   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75028   arg2 = (float)jarg2;
75029   arg3 = (float)jarg3;
75030   {
75031     try {
75032       (arg1)->SetMaxOvershoot(arg2,arg3);
75033     } catch (std::out_of_range& e) {
75034       {
75035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75036       };
75037     } catch (std::exception& e) {
75038       {
75039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75040       };
75041     } catch (Dali::DaliException e) {
75042       {
75043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75044       };
75045     } catch (...) {
75046       {
75047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75048       };
75049     }
75050   }
75051
75052 }
75053
75054
75055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
75056   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75057   Dali::AlphaFunction arg2 ;
75058   Dali::AlphaFunction *argp2 ;
75059
75060   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75061   argp2 = (Dali::AlphaFunction *)jarg2;
75062   if (!argp2) {
75063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75064     return ;
75065   }
75066   arg2 = *argp2;
75067   {
75068     try {
75069       (arg1)->SetSnapOvershootAlphaFunction(arg2);
75070     } catch (std::out_of_range& e) {
75071       {
75072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75073       };
75074     } catch (std::exception& e) {
75075       {
75076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75077       };
75078     } catch (Dali::DaliException e) {
75079       {
75080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75081       };
75082     } catch (...) {
75083       {
75084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75085       };
75086     }
75087   }
75088
75089 }
75090
75091
75092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
75093   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75094   float arg2 ;
75095
75096   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75097   arg2 = (float)jarg2;
75098   {
75099     try {
75100       (arg1)->SetSnapOvershootDuration(arg2);
75101     } catch (std::out_of_range& e) {
75102       {
75103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75104       };
75105     } catch (std::exception& e) {
75106       {
75107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75108       };
75109     } catch (Dali::DaliException e) {
75110       {
75111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75112       };
75113     } catch (...) {
75114       {
75115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75116       };
75117     }
75118   }
75119
75120 }
75121
75122
75123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
75124   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75125   bool arg2 ;
75126
75127   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75128   arg2 = jarg2 ? true : false;
75129   {
75130     try {
75131       (arg1)->SetActorAutoSnap(arg2);
75132     } catch (std::out_of_range& e) {
75133       {
75134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75135       };
75136     } catch (std::exception& e) {
75137       {
75138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75139       };
75140     } catch (Dali::DaliException e) {
75141       {
75142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75143       };
75144     } catch (...) {
75145       {
75146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75147       };
75148     }
75149   }
75150
75151 }
75152
75153
75154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
75155   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75156   bool arg2 ;
75157
75158   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75159   arg2 = jarg2 ? true : false;
75160   {
75161     try {
75162       (arg1)->SetWrapMode(arg2);
75163     } catch (std::out_of_range& e) {
75164       {
75165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75166       };
75167     } catch (std::exception& e) {
75168       {
75169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75170       };
75171     } catch (Dali::DaliException e) {
75172       {
75173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75174       };
75175     } catch (...) {
75176       {
75177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75178       };
75179     }
75180   }
75181
75182 }
75183
75184
75185 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
75186   int jresult ;
75187   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75188   int result;
75189
75190   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75191   {
75192     try {
75193       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
75194     } catch (std::out_of_range& e) {
75195       {
75196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75197       };
75198     } catch (std::exception& e) {
75199       {
75200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75201       };
75202     } catch (Dali::DaliException e) {
75203       {
75204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75205       };
75206     } catch (...) {
75207       {
75208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75209       };
75210     }
75211   }
75212
75213   jresult = result;
75214   return jresult;
75215 }
75216
75217
75218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
75219   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75220   int arg2 ;
75221
75222   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75223   arg2 = (int)jarg2;
75224   {
75225     try {
75226       (arg1)->SetScrollUpdateDistance(arg2);
75227     } catch (std::out_of_range& e) {
75228       {
75229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75230       };
75231     } catch (std::exception& e) {
75232       {
75233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75234       };
75235     } catch (Dali::DaliException e) {
75236       {
75237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75238       };
75239     } catch (...) {
75240       {
75241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75242       };
75243     }
75244   }
75245
75246 }
75247
75248
75249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
75250   unsigned int jresult ;
75251   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75252   bool result;
75253
75254   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75255   {
75256     try {
75257       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
75258     } catch (std::out_of_range& e) {
75259       {
75260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75261       };
75262     } catch (std::exception& e) {
75263       {
75264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75265       };
75266     } catch (Dali::DaliException e) {
75267       {
75268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75269       };
75270     } catch (...) {
75271       {
75272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75273       };
75274     }
75275   }
75276
75277   jresult = result;
75278   return jresult;
75279 }
75280
75281
75282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
75283   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75284   bool arg2 ;
75285
75286   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75287   arg2 = jarg2 ? true : false;
75288   {
75289     try {
75290       (arg1)->SetAxisAutoLock(arg2);
75291     } catch (std::out_of_range& e) {
75292       {
75293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75294       };
75295     } catch (std::exception& e) {
75296       {
75297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75298       };
75299     } catch (Dali::DaliException e) {
75300       {
75301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75302       };
75303     } catch (...) {
75304       {
75305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75306       };
75307     }
75308   }
75309
75310 }
75311
75312
75313 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
75314   float jresult ;
75315   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75316   float result;
75317
75318   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75319   {
75320     try {
75321       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
75322     } catch (std::out_of_range& e) {
75323       {
75324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75325       };
75326     } catch (std::exception& e) {
75327       {
75328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75329       };
75330     } catch (Dali::DaliException e) {
75331       {
75332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75333       };
75334     } catch (...) {
75335       {
75336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75337       };
75338     }
75339   }
75340
75341   jresult = result;
75342   return jresult;
75343 }
75344
75345
75346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
75347   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75348   float arg2 ;
75349
75350   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75351   arg2 = (float)jarg2;
75352   {
75353     try {
75354       (arg1)->SetAxisAutoLockGradient(arg2);
75355     } catch (std::out_of_range& e) {
75356       {
75357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75358       };
75359     } catch (std::exception& e) {
75360       {
75361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75362       };
75363     } catch (Dali::DaliException e) {
75364       {
75365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75366       };
75367     } catch (...) {
75368       {
75369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75370       };
75371     }
75372   }
75373
75374 }
75375
75376
75377 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
75378   float jresult ;
75379   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75380   float result;
75381
75382   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75383   {
75384     try {
75385       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75386     } catch (std::out_of_range& e) {
75387       {
75388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75389       };
75390     } catch (std::exception& e) {
75391       {
75392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75393       };
75394     } catch (Dali::DaliException e) {
75395       {
75396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75397       };
75398     } catch (...) {
75399       {
75400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75401       };
75402     }
75403   }
75404
75405   jresult = result;
75406   return jresult;
75407 }
75408
75409
75410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75411   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75412   float arg2 ;
75413
75414   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75415   arg2 = (float)jarg2;
75416   {
75417     try {
75418       (arg1)->SetFrictionCoefficient(arg2);
75419     } catch (std::out_of_range& e) {
75420       {
75421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75422       };
75423     } catch (std::exception& e) {
75424       {
75425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75426       };
75427     } catch (Dali::DaliException e) {
75428       {
75429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75430       };
75431     } catch (...) {
75432       {
75433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75434       };
75435     }
75436   }
75437
75438 }
75439
75440
75441 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75442   float jresult ;
75443   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75444   float result;
75445
75446   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75447   {
75448     try {
75449       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75450     } catch (std::out_of_range& e) {
75451       {
75452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75453       };
75454     } catch (std::exception& e) {
75455       {
75456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75457       };
75458     } catch (Dali::DaliException e) {
75459       {
75460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75461       };
75462     } catch (...) {
75463       {
75464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75465       };
75466     }
75467   }
75468
75469   jresult = result;
75470   return jresult;
75471 }
75472
75473
75474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75475   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75476   float arg2 ;
75477
75478   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75479   arg2 = (float)jarg2;
75480   {
75481     try {
75482       (arg1)->SetFlickSpeedCoefficient(arg2);
75483     } catch (std::out_of_range& e) {
75484       {
75485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75486       };
75487     } catch (std::exception& e) {
75488       {
75489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75490       };
75491     } catch (Dali::DaliException e) {
75492       {
75493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75494       };
75495     } catch (...) {
75496       {
75497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75498       };
75499     }
75500   }
75501
75502 }
75503
75504
75505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75506   void * jresult ;
75507   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75508   Dali::Vector2 result;
75509
75510   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75511   {
75512     try {
75513       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75514     } catch (std::out_of_range& e) {
75515       {
75516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75517       };
75518     } catch (std::exception& e) {
75519       {
75520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75521       };
75522     } catch (Dali::DaliException e) {
75523       {
75524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75525       };
75526     } catch (...) {
75527       {
75528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75529       };
75530     }
75531   }
75532
75533   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75534   return jresult;
75535 }
75536
75537
75538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75539   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75540   Dali::Vector2 *arg2 = 0 ;
75541
75542   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75543   arg2 = (Dali::Vector2 *)jarg2;
75544   if (!arg2) {
75545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75546     return ;
75547   }
75548   {
75549     try {
75550       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75551     } catch (std::out_of_range& e) {
75552       {
75553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75554       };
75555     } catch (std::exception& e) {
75556       {
75557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75558       };
75559     } catch (Dali::DaliException e) {
75560       {
75561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75562       };
75563     } catch (...) {
75564       {
75565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75566       };
75567     }
75568   }
75569
75570 }
75571
75572
75573 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75574   float jresult ;
75575   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75576   float result;
75577
75578   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75579   {
75580     try {
75581       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75582     } catch (std::out_of_range& e) {
75583       {
75584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75585       };
75586     } catch (std::exception& e) {
75587       {
75588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75589       };
75590     } catch (Dali::DaliException e) {
75591       {
75592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75593       };
75594     } catch (...) {
75595       {
75596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75597       };
75598     }
75599   }
75600
75601   jresult = result;
75602   return jresult;
75603 }
75604
75605
75606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75607   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75608   float arg2 ;
75609
75610   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75611   arg2 = (float)jarg2;
75612   {
75613     try {
75614       (arg1)->SetMinimumSpeedForFlick(arg2);
75615     } catch (std::out_of_range& e) {
75616       {
75617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75618       };
75619     } catch (std::exception& e) {
75620       {
75621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75622       };
75623     } catch (Dali::DaliException e) {
75624       {
75625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75626       };
75627     } catch (...) {
75628       {
75629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75630       };
75631     }
75632   }
75633
75634 }
75635
75636
75637 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75638   float jresult ;
75639   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75640   float result;
75641
75642   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75643   {
75644     try {
75645       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
75646     } catch (std::out_of_range& e) {
75647       {
75648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75649       };
75650     } catch (std::exception& e) {
75651       {
75652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75653       };
75654     } catch (Dali::DaliException e) {
75655       {
75656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75657       };
75658     } catch (...) {
75659       {
75660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75661       };
75662     }
75663   }
75664
75665   jresult = result;
75666   return jresult;
75667 }
75668
75669
75670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75671   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75672   float arg2 ;
75673
75674   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75675   arg2 = (float)jarg2;
75676   {
75677     try {
75678       (arg1)->SetMaxFlickSpeed(arg2);
75679     } catch (std::out_of_range& e) {
75680       {
75681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75682       };
75683     } catch (std::exception& e) {
75684       {
75685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75686       };
75687     } catch (Dali::DaliException e) {
75688       {
75689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75690       };
75691     } catch (...) {
75692       {
75693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75694       };
75695     }
75696   }
75697
75698 }
75699
75700
75701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75702   void * jresult ;
75703   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75704   Dali::Vector2 result;
75705
75706   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75707   {
75708     try {
75709       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75710     } catch (std::out_of_range& e) {
75711       {
75712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75713       };
75714     } catch (std::exception& e) {
75715       {
75716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75717       };
75718     } catch (Dali::DaliException e) {
75719       {
75720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75721       };
75722     } catch (...) {
75723       {
75724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75725       };
75726     }
75727   }
75728
75729   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75730   return jresult;
75731 }
75732
75733
75734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75735   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75736   Dali::Vector2 arg2 ;
75737   Dali::Vector2 *argp2 ;
75738
75739   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75740   argp2 = (Dali::Vector2 *)jarg2;
75741   if (!argp2) {
75742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75743     return ;
75744   }
75745   arg2 = *argp2;
75746   {
75747     try {
75748       (arg1)->SetWheelScrollDistanceStep(arg2);
75749     } catch (std::out_of_range& e) {
75750       {
75751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75752       };
75753     } catch (std::exception& e) {
75754       {
75755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75756       };
75757     } catch (Dali::DaliException e) {
75758       {
75759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75760       };
75761     } catch (...) {
75762       {
75763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75764       };
75765     }
75766   }
75767
75768 }
75769
75770
75771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
75772   void * jresult ;
75773   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75774   Dali::Vector2 result;
75775
75776   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75777   {
75778     try {
75779       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
75780     } catch (std::out_of_range& e) {
75781       {
75782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75783       };
75784     } catch (std::exception& e) {
75785       {
75786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75787       };
75788     } catch (Dali::DaliException e) {
75789       {
75790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75791       };
75792     } catch (...) {
75793       {
75794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75795       };
75796     }
75797   }
75798
75799   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75800   return jresult;
75801 }
75802
75803
75804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
75805   unsigned int jresult ;
75806   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75807   unsigned int result;
75808
75809   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75810   {
75811     try {
75812       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
75813     } catch (std::out_of_range& e) {
75814       {
75815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75816       };
75817     } catch (std::exception& e) {
75818       {
75819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75820       };
75821     } catch (Dali::DaliException e) {
75822       {
75823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75824       };
75825     } catch (...) {
75826       {
75827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75828       };
75829     }
75830   }
75831
75832   jresult = result;
75833   return jresult;
75834 }
75835
75836
75837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
75838   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75839   Dali::Vector2 *arg2 = 0 ;
75840
75841   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75842   arg2 = (Dali::Vector2 *)jarg2;
75843   if (!arg2) {
75844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75845     return ;
75846   }
75847   {
75848     try {
75849       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
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_1(void * jarg1, void * jarg2, float jarg3) {
75873   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75874   Dali::Vector2 *arg2 = 0 ;
75875   float arg3 ;
75876
75877   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75878   arg2 = (Dali::Vector2 *)jarg2;
75879   if (!arg2) {
75880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75881     return ;
75882   }
75883   arg3 = (float)jarg3;
75884   {
75885     try {
75886       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
75887     } catch (std::out_of_range& e) {
75888       {
75889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75890       };
75891     } catch (std::exception& e) {
75892       {
75893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75894       };
75895     } catch (Dali::DaliException e) {
75896       {
75897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75898       };
75899     } catch (...) {
75900       {
75901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75902       };
75903     }
75904   }
75905
75906 }
75907
75908
75909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
75910   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75911   Dali::Vector2 *arg2 = 0 ;
75912   float arg3 ;
75913   Dali::AlphaFunction arg4 ;
75914   Dali::AlphaFunction *argp4 ;
75915
75916   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75917   arg2 = (Dali::Vector2 *)jarg2;
75918   if (!arg2) {
75919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75920     return ;
75921   }
75922   arg3 = (float)jarg3;
75923   argp4 = (Dali::AlphaFunction *)jarg4;
75924   if (!argp4) {
75925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75926     return ;
75927   }
75928   arg4 = *argp4;
75929   {
75930     try {
75931       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
75932     } catch (std::out_of_range& e) {
75933       {
75934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75935       };
75936     } catch (std::exception& e) {
75937       {
75938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75939       };
75940     } catch (Dali::DaliException e) {
75941       {
75942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75943       };
75944     } catch (...) {
75945       {
75946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75947       };
75948     }
75949   }
75950
75951 }
75952
75953
75954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
75955   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75956   Dali::Vector2 *arg2 = 0 ;
75957   float arg3 ;
75958   Dali::Toolkit::DirectionBias arg4 ;
75959   Dali::Toolkit::DirectionBias arg5 ;
75960
75961   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75962   arg2 = (Dali::Vector2 *)jarg2;
75963   if (!arg2) {
75964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75965     return ;
75966   }
75967   arg3 = (float)jarg3;
75968   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
75969   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
75970   {
75971     try {
75972       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
75973     } catch (std::out_of_range& e) {
75974       {
75975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75976       };
75977     } catch (std::exception& e) {
75978       {
75979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75980       };
75981     } catch (Dali::DaliException e) {
75982       {
75983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75984       };
75985     } catch (...) {
75986       {
75987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75988       };
75989     }
75990   }
75991
75992 }
75993
75994
75995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
75996   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75997   Dali::Vector2 *arg2 = 0 ;
75998   float arg3 ;
75999   Dali::AlphaFunction arg4 ;
76000   Dali::Toolkit::DirectionBias arg5 ;
76001   Dali::Toolkit::DirectionBias arg6 ;
76002   Dali::AlphaFunction *argp4 ;
76003
76004   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76005   arg2 = (Dali::Vector2 *)jarg2;
76006   if (!arg2) {
76007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76008     return ;
76009   }
76010   arg3 = (float)jarg3;
76011   argp4 = (Dali::AlphaFunction *)jarg4;
76012   if (!argp4) {
76013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76014     return ;
76015   }
76016   arg4 = *argp4;
76017   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76018   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
76019   {
76020     try {
76021       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
76022     } catch (std::out_of_range& e) {
76023       {
76024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76025       };
76026     } catch (std::exception& e) {
76027       {
76028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76029       };
76030     } catch (Dali::DaliException e) {
76031       {
76032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76033       };
76034     } catch (...) {
76035       {
76036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76037       };
76038     }
76039   }
76040
76041 }
76042
76043
76044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
76045   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76046   unsigned int arg2 ;
76047
76048   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76049   arg2 = (unsigned int)jarg2;
76050   {
76051     try {
76052       (arg1)->ScrollTo(arg2);
76053     } catch (std::out_of_range& e) {
76054       {
76055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76056       };
76057     } catch (std::exception& e) {
76058       {
76059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76060       };
76061     } catch (Dali::DaliException e) {
76062       {
76063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76064       };
76065     } catch (...) {
76066       {
76067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76068       };
76069     }
76070   }
76071
76072 }
76073
76074
76075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
76076   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76077   unsigned int arg2 ;
76078   float arg3 ;
76079
76080   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76081   arg2 = (unsigned int)jarg2;
76082   arg3 = (float)jarg3;
76083   {
76084     try {
76085       (arg1)->ScrollTo(arg2,arg3);
76086     } catch (std::out_of_range& e) {
76087       {
76088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76089       };
76090     } catch (std::exception& e) {
76091       {
76092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76093       };
76094     } catch (Dali::DaliException e) {
76095       {
76096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76097       };
76098     } catch (...) {
76099       {
76100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76101       };
76102     }
76103   }
76104
76105 }
76106
76107
76108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
76109   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76110   unsigned int arg2 ;
76111   float arg3 ;
76112   Dali::Toolkit::DirectionBias arg4 ;
76113
76114   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76115   arg2 = (unsigned int)jarg2;
76116   arg3 = (float)jarg3;
76117   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76118   {
76119     try {
76120       (arg1)->ScrollTo(arg2,arg3,arg4);
76121     } catch (std::out_of_range& e) {
76122       {
76123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76124       };
76125     } catch (std::exception& e) {
76126       {
76127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76128       };
76129     } catch (Dali::DaliException e) {
76130       {
76131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76132       };
76133     } catch (...) {
76134       {
76135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76136       };
76137     }
76138   }
76139
76140 }
76141
76142
76143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
76144   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76145   Dali::Actor *arg2 = 0 ;
76146
76147   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76148   arg2 = (Dali::Actor *)jarg2;
76149   if (!arg2) {
76150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76151     return ;
76152   }
76153   {
76154     try {
76155       (arg1)->ScrollTo(*arg2);
76156     } catch (std::out_of_range& e) {
76157       {
76158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76159       };
76160     } catch (std::exception& e) {
76161       {
76162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76163       };
76164     } catch (Dali::DaliException e) {
76165       {
76166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76167       };
76168     } catch (...) {
76169       {
76170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76171       };
76172     }
76173   }
76174
76175 }
76176
76177
76178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
76179   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76180   Dali::Actor *arg2 = 0 ;
76181   float arg3 ;
76182
76183   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76184   arg2 = (Dali::Actor *)jarg2;
76185   if (!arg2) {
76186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76187     return ;
76188   }
76189   arg3 = (float)jarg3;
76190   {
76191     try {
76192       (arg1)->ScrollTo(*arg2,arg3);
76193     } catch (std::out_of_range& e) {
76194       {
76195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76196       };
76197     } catch (std::exception& e) {
76198       {
76199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76200       };
76201     } catch (Dali::DaliException e) {
76202       {
76203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76204       };
76205     } catch (...) {
76206       {
76207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76208       };
76209     }
76210   }
76211
76212 }
76213
76214
76215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
76216   unsigned int jresult ;
76217   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76218   bool result;
76219
76220   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76221   {
76222     try {
76223       result = (bool)(arg1)->ScrollToSnapPoint();
76224     } catch (std::out_of_range& e) {
76225       {
76226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76227       };
76228     } catch (std::exception& e) {
76229       {
76230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76231       };
76232     } catch (Dali::DaliException e) {
76233       {
76234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76235       };
76236     } catch (...) {
76237       {
76238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76239       };
76240     }
76241   }
76242
76243   jresult = result;
76244   return jresult;
76245 }
76246
76247
76248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
76249   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76250   Dali::Constraint arg2 ;
76251   Dali::Constraint *argp2 ;
76252
76253   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76254   argp2 = (Dali::Constraint *)jarg2;
76255   if (!argp2) {
76256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
76257     return ;
76258   }
76259   arg2 = *argp2;
76260   {
76261     try {
76262       (arg1)->ApplyConstraintToChildren(arg2);
76263     } catch (std::out_of_range& e) {
76264       {
76265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76266       };
76267     } catch (std::exception& e) {
76268       {
76269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76270       };
76271     } catch (Dali::DaliException e) {
76272       {
76273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76274       };
76275     } catch (...) {
76276       {
76277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76278       };
76279     }
76280   }
76281
76282 }
76283
76284
76285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
76286   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76287
76288   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76289   {
76290     try {
76291       (arg1)->RemoveConstraintsFromChildren();
76292     } catch (std::out_of_range& e) {
76293       {
76294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76295       };
76296     } catch (std::exception& e) {
76297       {
76298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76299       };
76300     } catch (Dali::DaliException e) {
76301       {
76302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76303       };
76304     } catch (...) {
76305       {
76306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76307       };
76308     }
76309   }
76310
76311 }
76312
76313
76314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
76315   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76316   Dali::Toolkit::ScrollViewEffect arg2 ;
76317   Dali::Toolkit::ScrollViewEffect *argp2 ;
76318
76319   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76320   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76321   if (!argp2) {
76322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76323     return ;
76324   }
76325   arg2 = *argp2;
76326   {
76327     try {
76328       (arg1)->ApplyEffect(arg2);
76329     } catch (std::out_of_range& e) {
76330       {
76331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76332       };
76333     } catch (std::exception& e) {
76334       {
76335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76336       };
76337     } catch (Dali::DaliException e) {
76338       {
76339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76340       };
76341     } catch (...) {
76342       {
76343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76344       };
76345     }
76346   }
76347
76348 }
76349
76350
76351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
76352   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76353   Dali::Toolkit::ScrollViewEffect arg2 ;
76354   Dali::Toolkit::ScrollViewEffect *argp2 ;
76355
76356   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76357   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76358   if (!argp2) {
76359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76360     return ;
76361   }
76362   arg2 = *argp2;
76363   {
76364     try {
76365       (arg1)->RemoveEffect(arg2);
76366     } catch (std::out_of_range& e) {
76367       {
76368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76369       };
76370     } catch (std::exception& e) {
76371       {
76372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76373       };
76374     } catch (Dali::DaliException e) {
76375       {
76376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76377       };
76378     } catch (...) {
76379       {
76380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76381       };
76382     }
76383   }
76384
76385 }
76386
76387
76388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
76389   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76390
76391   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76392   {
76393     try {
76394       (arg1)->RemoveAllEffects();
76395     } catch (std::out_of_range& e) {
76396       {
76397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76398       };
76399     } catch (std::exception& e) {
76400       {
76401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76402       };
76403     } catch (Dali::DaliException e) {
76404       {
76405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76406       };
76407     } catch (...) {
76408       {
76409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76410       };
76411     }
76412   }
76413
76414 }
76415
76416
76417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
76418   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76419   Dali::Actor arg2 ;
76420   Dali::Actor *argp2 ;
76421
76422   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76423   argp2 = (Dali::Actor *)jarg2;
76424   if (!argp2) {
76425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76426     return ;
76427   }
76428   arg2 = *argp2;
76429   {
76430     try {
76431       (arg1)->BindActor(arg2);
76432     } catch (std::out_of_range& e) {
76433       {
76434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76435       };
76436     } catch (std::exception& e) {
76437       {
76438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76439       };
76440     } catch (Dali::DaliException e) {
76441       {
76442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76443       };
76444     } catch (...) {
76445       {
76446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76447       };
76448     }
76449   }
76450
76451 }
76452
76453
76454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
76455   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76456   Dali::Actor arg2 ;
76457   Dali::Actor *argp2 ;
76458
76459   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76460   argp2 = (Dali::Actor *)jarg2;
76461   if (!argp2) {
76462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76463     return ;
76464   }
76465   arg2 = *argp2;
76466   {
76467     try {
76468       (arg1)->UnbindActor(arg2);
76469     } catch (std::out_of_range& e) {
76470       {
76471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76472       };
76473     } catch (std::exception& e) {
76474       {
76475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76476       };
76477     } catch (Dali::DaliException e) {
76478       {
76479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76480       };
76481     } catch (...) {
76482       {
76483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76484       };
76485     }
76486   }
76487
76488 }
76489
76490
76491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
76492   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76493   Dali::Radian arg2 ;
76494   Dali::Radian arg3 ;
76495   Dali::Radian *argp2 ;
76496   Dali::Radian *argp3 ;
76497
76498   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76499   argp2 = (Dali::Radian *)jarg2;
76500   if (!argp2) {
76501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76502     return ;
76503   }
76504   arg2 = *argp2;
76505   argp3 = (Dali::Radian *)jarg3;
76506   if (!argp3) {
76507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76508     return ;
76509   }
76510   arg3 = *argp3;
76511   {
76512     try {
76513       (arg1)->SetScrollingDirection(arg2,arg3);
76514     } catch (std::out_of_range& e) {
76515       {
76516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76517       };
76518     } catch (std::exception& e) {
76519       {
76520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76521       };
76522     } catch (Dali::DaliException e) {
76523       {
76524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76525       };
76526     } catch (...) {
76527       {
76528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76529       };
76530     }
76531   }
76532
76533 }
76534
76535
76536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
76537   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76538   Dali::Radian arg2 ;
76539   Dali::Radian *argp2 ;
76540
76541   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76542   argp2 = (Dali::Radian *)jarg2;
76543   if (!argp2) {
76544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76545     return ;
76546   }
76547   arg2 = *argp2;
76548   {
76549     try {
76550       (arg1)->SetScrollingDirection(arg2);
76551     } catch (std::out_of_range& e) {
76552       {
76553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76554       };
76555     } catch (std::exception& e) {
76556       {
76557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76558       };
76559     } catch (Dali::DaliException e) {
76560       {
76561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76562       };
76563     } catch (...) {
76564       {
76565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76566       };
76567     }
76568   }
76569
76570 }
76571
76572
76573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76574   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76575   Dali::Radian arg2 ;
76576   Dali::Radian *argp2 ;
76577
76578   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76579   argp2 = (Dali::Radian *)jarg2;
76580   if (!argp2) {
76581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76582     return ;
76583   }
76584   arg2 = *argp2;
76585   {
76586     try {
76587       (arg1)->RemoveScrollingDirection(arg2);
76588     } catch (std::out_of_range& e) {
76589       {
76590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76591       };
76592     } catch (std::exception& e) {
76593       {
76594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76595       };
76596     } catch (Dali::DaliException e) {
76597       {
76598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76599       };
76600     } catch (...) {
76601       {
76602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76603       };
76604     }
76605   }
76606
76607 }
76608
76609
76610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76611   void * jresult ;
76612   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76613   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76614
76615   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76616   {
76617     try {
76618       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
76619     } catch (std::out_of_range& e) {
76620       {
76621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76622       };
76623     } catch (std::exception& e) {
76624       {
76625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76626       };
76627     } catch (Dali::DaliException e) {
76628       {
76629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76630       };
76631     } catch (...) {
76632       {
76633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76634       };
76635     }
76636   }
76637
76638   jresult = (void *)result;
76639   return jresult;
76640 }
76641
76642
76643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76644   int jresult ;
76645   int result;
76646
76647   result = (int)Dali::Toolkit::TableView::Property::ROWS;
76648   jresult = (int)result;
76649   return jresult;
76650 }
76651
76652
76653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
76654   int jresult ;
76655   int result;
76656
76657   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
76658   jresult = (int)result;
76659   return jresult;
76660 }
76661
76662
76663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
76664   int jresult ;
76665   int result;
76666
76667   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
76668   jresult = (int)result;
76669   return jresult;
76670 }
76671
76672
76673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
76674   int jresult ;
76675   int result;
76676
76677   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
76678   jresult = (int)result;
76679   return jresult;
76680 }
76681
76682
76683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
76684   int jresult ;
76685   int result;
76686
76687   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
76688   jresult = (int)result;
76689   return jresult;
76690 }
76691
76692
76693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
76694   void * jresult ;
76695   Dali::Toolkit::TableView::Property *result = 0 ;
76696
76697   {
76698     try {
76699       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
76700     } catch (std::out_of_range& e) {
76701       {
76702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76703       };
76704     } catch (std::exception& e) {
76705       {
76706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76707       };
76708     } catch (Dali::DaliException e) {
76709       {
76710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76711       };
76712     } catch (...) {
76713       {
76714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76715       };
76716     }
76717   }
76718
76719   jresult = (void *)result;
76720   return jresult;
76721 }
76722
76723
76724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
76725   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
76726
76727   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
76728   {
76729     try {
76730       delete arg1;
76731     } catch (std::out_of_range& e) {
76732       {
76733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76734       };
76735     } catch (std::exception& e) {
76736       {
76737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76738       };
76739     } catch (Dali::DaliException e) {
76740       {
76741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76742       };
76743     } catch (...) {
76744       {
76745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76746       };
76747     }
76748   }
76749
76750 }
76751
76752
76753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
76754   int jresult ;
76755   int result;
76756
76757   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
76758   jresult = (int)result;
76759   return jresult;
76760 }
76761
76762
76763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
76764   int jresult ;
76765   int result;
76766
76767   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
76768   jresult = (int)result;
76769   return jresult;
76770 }
76771
76772
76773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
76774   int jresult ;
76775   int result;
76776
76777   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
76778   jresult = (int)result;
76779   return jresult;
76780 }
76781
76782
76783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
76784   int jresult ;
76785   int result;
76786
76787   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
76788   jresult = (int)result;
76789   return jresult;
76790 }
76791
76792
76793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
76794   int jresult ;
76795   int result;
76796
76797   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
76798   jresult = (int)result;
76799   return jresult;
76800 }
76801
76802
76803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
76804   void * jresult ;
76805   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
76806
76807   {
76808     try {
76809       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
76810     } catch (std::out_of_range& e) {
76811       {
76812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76813       };
76814     } catch (std::exception& e) {
76815       {
76816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76817       };
76818     } catch (Dali::DaliException e) {
76819       {
76820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76821       };
76822     } catch (...) {
76823       {
76824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76825       };
76826     }
76827   }
76828
76829   jresult = (void *)result;
76830   return jresult;
76831 }
76832
76833
76834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
76835   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
76836
76837   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
76838   {
76839     try {
76840       delete arg1;
76841     } catch (std::out_of_range& e) {
76842       {
76843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76844       };
76845     } catch (std::exception& e) {
76846       {
76847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76848       };
76849     } catch (Dali::DaliException e) {
76850       {
76851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76852       };
76853     } catch (...) {
76854       {
76855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76856       };
76857     }
76858   }
76859
76860 }
76861
76862
76863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
76864   void * jresult ;
76865   unsigned int arg1 ;
76866   unsigned int arg2 ;
76867   unsigned int arg3 ;
76868   unsigned int arg4 ;
76869   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76870
76871   arg1 = (unsigned int)jarg1;
76872   arg2 = (unsigned int)jarg2;
76873   arg3 = (unsigned int)jarg3;
76874   arg4 = (unsigned int)jarg4;
76875   {
76876     try {
76877       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
76878     } catch (std::out_of_range& e) {
76879       {
76880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76881       };
76882     } catch (std::exception& e) {
76883       {
76884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76885       };
76886     } catch (Dali::DaliException e) {
76887       {
76888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76889       };
76890     } catch (...) {
76891       {
76892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76893       };
76894     }
76895   }
76896
76897   jresult = (void *)result;
76898   return jresult;
76899 }
76900
76901
76902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
76903   void * jresult ;
76904   unsigned int arg1 ;
76905   unsigned int arg2 ;
76906   unsigned int arg3 ;
76907   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76908
76909   arg1 = (unsigned int)jarg1;
76910   arg2 = (unsigned int)jarg2;
76911   arg3 = (unsigned int)jarg3;
76912   {
76913     try {
76914       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
76915     } catch (std::out_of_range& e) {
76916       {
76917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76918       };
76919     } catch (std::exception& e) {
76920       {
76921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76922       };
76923     } catch (Dali::DaliException e) {
76924       {
76925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76926       };
76927     } catch (...) {
76928       {
76929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76930       };
76931     }
76932   }
76933
76934   jresult = (void *)result;
76935   return jresult;
76936 }
76937
76938
76939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
76940   void * jresult ;
76941   unsigned int arg1 ;
76942   unsigned int arg2 ;
76943   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76944
76945   arg1 = (unsigned int)jarg1;
76946   arg2 = (unsigned int)jarg2;
76947   {
76948     try {
76949       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
76950     } catch (std::out_of_range& e) {
76951       {
76952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76953       };
76954     } catch (std::exception& e) {
76955       {
76956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76957       };
76958     } catch (Dali::DaliException e) {
76959       {
76960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76961       };
76962     } catch (...) {
76963       {
76964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76965       };
76966     }
76967   }
76968
76969   jresult = (void *)result;
76970   return jresult;
76971 }
76972
76973
76974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
76975   void * jresult ;
76976   unsigned int arg1 ;
76977   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76978
76979   arg1 = (unsigned int)jarg1;
76980   {
76981     try {
76982       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
76983     } catch (std::out_of_range& e) {
76984       {
76985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76986       };
76987     } catch (std::exception& e) {
76988       {
76989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76990       };
76991     } catch (Dali::DaliException e) {
76992       {
76993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76994       };
76995     } catch (...) {
76996       {
76997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76998       };
76999     }
77000   }
77001
77002   jresult = (void *)result;
77003   return jresult;
77004 }
77005
77006
77007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
77008   void * jresult ;
77009   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77010
77011   {
77012     try {
77013       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
77014     } catch (std::out_of_range& e) {
77015       {
77016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77017       };
77018     } catch (std::exception& e) {
77019       {
77020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77021       };
77022     } catch (Dali::DaliException e) {
77023       {
77024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77025       };
77026     } catch (...) {
77027       {
77028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77029       };
77030     }
77031   }
77032
77033   jresult = (void *)result;
77034   return jresult;
77035 }
77036
77037
77038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
77039   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77040   unsigned int arg2 ;
77041
77042   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77043   arg2 = (unsigned int)jarg2;
77044   if (arg1) (arg1)->rowIndex = arg2;
77045 }
77046
77047
77048 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
77049   unsigned int jresult ;
77050   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77051   unsigned int result;
77052
77053   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77054   result = (unsigned int) ((arg1)->rowIndex);
77055   jresult = result;
77056   return jresult;
77057 }
77058
77059
77060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
77061   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77062   unsigned int arg2 ;
77063
77064   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77065   arg2 = (unsigned int)jarg2;
77066   if (arg1) (arg1)->columnIndex = arg2;
77067 }
77068
77069
77070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
77071   unsigned int jresult ;
77072   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77073   unsigned int result;
77074
77075   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77076   result = (unsigned int) ((arg1)->columnIndex);
77077   jresult = result;
77078   return jresult;
77079 }
77080
77081
77082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
77083   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77084   unsigned int arg2 ;
77085
77086   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77087   arg2 = (unsigned int)jarg2;
77088   if (arg1) (arg1)->rowSpan = arg2;
77089 }
77090
77091
77092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
77093   unsigned int jresult ;
77094   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77095   unsigned int result;
77096
77097   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77098   result = (unsigned int) ((arg1)->rowSpan);
77099   jresult = result;
77100   return jresult;
77101 }
77102
77103
77104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
77105   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77106   unsigned int arg2 ;
77107
77108   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77109   arg2 = (unsigned int)jarg2;
77110   if (arg1) (arg1)->columnSpan = arg2;
77111 }
77112
77113
77114 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
77115   unsigned int jresult ;
77116   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77117   unsigned int result;
77118
77119   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77120   result = (unsigned int) ((arg1)->columnSpan);
77121   jresult = result;
77122   return jresult;
77123 }
77124
77125
77126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
77127   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77128
77129   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77130   {
77131     try {
77132       delete arg1;
77133     } catch (std::out_of_range& e) {
77134       {
77135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77136       };
77137     } catch (std::exception& e) {
77138       {
77139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77140       };
77141     } catch (Dali::DaliException e) {
77142       {
77143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77144       };
77145     } catch (...) {
77146       {
77147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77148       };
77149     }
77150   }
77151
77152 }
77153
77154
77155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
77156   void * jresult ;
77157   Dali::Toolkit::TableView *result = 0 ;
77158
77159   {
77160     try {
77161       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
77162     } catch (std::out_of_range& e) {
77163       {
77164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77165       };
77166     } catch (std::exception& e) {
77167       {
77168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77169       };
77170     } catch (Dali::DaliException e) {
77171       {
77172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77173       };
77174     } catch (...) {
77175       {
77176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77177       };
77178     }
77179   }
77180
77181   jresult = (void *)result;
77182   return jresult;
77183 }
77184
77185
77186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
77187   void * jresult ;
77188   Dali::Toolkit::TableView *arg1 = 0 ;
77189   Dali::Toolkit::TableView *result = 0 ;
77190
77191   arg1 = (Dali::Toolkit::TableView *)jarg1;
77192   if (!arg1) {
77193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77194     return 0;
77195   }
77196   {
77197     try {
77198       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
77199     } catch (std::out_of_range& e) {
77200       {
77201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77202       };
77203     } catch (std::exception& e) {
77204       {
77205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77206       };
77207     } catch (Dali::DaliException e) {
77208       {
77209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77210       };
77211     } catch (...) {
77212       {
77213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77214       };
77215     }
77216   }
77217
77218   jresult = (void *)result;
77219   return jresult;
77220 }
77221
77222
77223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
77224   void * jresult ;
77225   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77226   Dali::Toolkit::TableView *arg2 = 0 ;
77227   Dali::Toolkit::TableView *result = 0 ;
77228
77229   arg1 = (Dali::Toolkit::TableView *)jarg1;
77230   arg2 = (Dali::Toolkit::TableView *)jarg2;
77231   if (!arg2) {
77232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77233     return 0;
77234   }
77235   {
77236     try {
77237       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
77238     } catch (std::out_of_range& e) {
77239       {
77240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77241       };
77242     } catch (std::exception& e) {
77243       {
77244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77245       };
77246     } catch (Dali::DaliException e) {
77247       {
77248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77249       };
77250     } catch (...) {
77251       {
77252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77253       };
77254     }
77255   }
77256
77257   jresult = (void *)result;
77258   return jresult;
77259 }
77260
77261
77262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
77263   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77264
77265   arg1 = (Dali::Toolkit::TableView *)jarg1;
77266   {
77267     try {
77268       delete arg1;
77269     } catch (std::out_of_range& e) {
77270       {
77271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77272       };
77273     } catch (std::exception& e) {
77274       {
77275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77276       };
77277     } catch (Dali::DaliException e) {
77278       {
77279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77280       };
77281     } catch (...) {
77282       {
77283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77284       };
77285     }
77286   }
77287
77288 }
77289
77290
77291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
77292   void * jresult ;
77293   unsigned int arg1 ;
77294   unsigned int arg2 ;
77295   Dali::Toolkit::TableView result;
77296
77297   arg1 = (unsigned int)jarg1;
77298   arg2 = (unsigned int)jarg2;
77299   {
77300     try {
77301       result = Dali::Toolkit::TableView::New(arg1,arg2);
77302     } catch (std::out_of_range& e) {
77303       {
77304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77305       };
77306     } catch (std::exception& e) {
77307       {
77308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77309       };
77310     } catch (Dali::DaliException e) {
77311       {
77312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77313       };
77314     } catch (...) {
77315       {
77316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77317       };
77318     }
77319   }
77320
77321   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77322   return jresult;
77323 }
77324
77325
77326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
77327   void * jresult ;
77328   Dali::BaseHandle arg1 ;
77329   Dali::BaseHandle *argp1 ;
77330   Dali::Toolkit::TableView result;
77331
77332   argp1 = (Dali::BaseHandle *)jarg1;
77333   if (!argp1) {
77334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77335     return 0;
77336   }
77337   arg1 = *argp1;
77338   {
77339     try {
77340       result = Dali::Toolkit::TableView::DownCast(arg1);
77341     } catch (std::out_of_range& e) {
77342       {
77343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77344       };
77345     } catch (std::exception& e) {
77346       {
77347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77348       };
77349     } catch (Dali::DaliException e) {
77350       {
77351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77352       };
77353     } catch (...) {
77354       {
77355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77356       };
77357     }
77358   }
77359
77360   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77361   return jresult;
77362 }
77363
77364
77365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
77366   unsigned int jresult ;
77367   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77368   Dali::Actor arg2 ;
77369   Dali::Toolkit::TableView::CellPosition arg3 ;
77370   Dali::Actor *argp2 ;
77371   Dali::Toolkit::TableView::CellPosition *argp3 ;
77372   bool result;
77373
77374   arg1 = (Dali::Toolkit::TableView *)jarg1;
77375   argp2 = (Dali::Actor *)jarg2;
77376   if (!argp2) {
77377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77378     return 0;
77379   }
77380   arg2 = *argp2;
77381   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77382   if (!argp3) {
77383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77384     return 0;
77385   }
77386   arg3 = *argp3;
77387   {
77388     try {
77389       result = (bool)(arg1)->AddChild(arg2,arg3);
77390     } catch (std::out_of_range& e) {
77391       {
77392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77393       };
77394     } catch (std::exception& e) {
77395       {
77396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77397       };
77398     } catch (Dali::DaliException e) {
77399       {
77400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77401       };
77402     } catch (...) {
77403       {
77404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77405       };
77406     }
77407   }
77408
77409   jresult = result;
77410   return jresult;
77411 }
77412
77413
77414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
77415   void * jresult ;
77416   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77417   Dali::Toolkit::TableView::CellPosition arg2 ;
77418   Dali::Toolkit::TableView::CellPosition *argp2 ;
77419   Dali::Actor result;
77420
77421   arg1 = (Dali::Toolkit::TableView *)jarg1;
77422   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77423   if (!argp2) {
77424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77425     return 0;
77426   }
77427   arg2 = *argp2;
77428   {
77429     try {
77430       result = (arg1)->GetChildAt(arg2);
77431     } catch (std::out_of_range& e) {
77432       {
77433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77434       };
77435     } catch (std::exception& e) {
77436       {
77437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77438       };
77439     } catch (Dali::DaliException e) {
77440       {
77441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77442       };
77443     } catch (...) {
77444       {
77445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77446       };
77447     }
77448   }
77449
77450   jresult = new Dali::Actor((const Dali::Actor &)result);
77451   return jresult;
77452 }
77453
77454
77455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
77456   void * jresult ;
77457   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77458   Dali::Toolkit::TableView::CellPosition arg2 ;
77459   Dali::Toolkit::TableView::CellPosition *argp2 ;
77460   Dali::Actor result;
77461
77462   arg1 = (Dali::Toolkit::TableView *)jarg1;
77463   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77464   if (!argp2) {
77465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77466     return 0;
77467   }
77468   arg2 = *argp2;
77469   {
77470     try {
77471       result = (arg1)->RemoveChildAt(arg2);
77472     } catch (std::out_of_range& e) {
77473       {
77474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77475       };
77476     } catch (std::exception& e) {
77477       {
77478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77479       };
77480     } catch (Dali::DaliException e) {
77481       {
77482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77483       };
77484     } catch (...) {
77485       {
77486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77487       };
77488     }
77489   }
77490
77491   jresult = new Dali::Actor((const Dali::Actor &)result);
77492   return jresult;
77493 }
77494
77495
77496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
77497   unsigned int jresult ;
77498   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77499   Dali::Actor arg2 ;
77500   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
77501   Dali::Actor *argp2 ;
77502   bool result;
77503
77504   arg1 = (Dali::Toolkit::TableView *)jarg1;
77505   argp2 = (Dali::Actor *)jarg2;
77506   if (!argp2) {
77507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77508     return 0;
77509   }
77510   arg2 = *argp2;
77511   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77512   if (!arg3) {
77513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
77514     return 0;
77515   }
77516   {
77517     try {
77518       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
77519     } catch (std::out_of_range& e) {
77520       {
77521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77522       };
77523     } catch (std::exception& e) {
77524       {
77525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77526       };
77527     } catch (Dali::DaliException e) {
77528       {
77529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77530       };
77531     } catch (...) {
77532       {
77533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77534       };
77535     }
77536   }
77537
77538   jresult = result;
77539   return jresult;
77540 }
77541
77542
77543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
77544   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77545   unsigned int arg2 ;
77546
77547   arg1 = (Dali::Toolkit::TableView *)jarg1;
77548   arg2 = (unsigned int)jarg2;
77549   {
77550     try {
77551       (arg1)->InsertRow(arg2);
77552     } catch (std::out_of_range& e) {
77553       {
77554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77555       };
77556     } catch (std::exception& e) {
77557       {
77558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77559       };
77560     } catch (Dali::DaliException e) {
77561       {
77562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77563       };
77564     } catch (...) {
77565       {
77566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77567       };
77568     }
77569   }
77570
77571 }
77572
77573
77574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
77575   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77576   unsigned int arg2 ;
77577
77578   arg1 = (Dali::Toolkit::TableView *)jarg1;
77579   arg2 = (unsigned int)jarg2;
77580   {
77581     try {
77582       (arg1)->DeleteRow(arg2);
77583     } catch (std::out_of_range& e) {
77584       {
77585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77586       };
77587     } catch (std::exception& e) {
77588       {
77589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77590       };
77591     } catch (Dali::DaliException e) {
77592       {
77593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77594       };
77595     } catch (...) {
77596       {
77597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77598       };
77599     }
77600   }
77601
77602 }
77603
77604
77605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77606   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77607   unsigned int arg2 ;
77608   std::vector< Dali::Actor > *arg3 = 0 ;
77609
77610   arg1 = (Dali::Toolkit::TableView *)jarg1;
77611   arg2 = (unsigned int)jarg2;
77612   arg3 = (std::vector< Dali::Actor > *)jarg3;
77613   if (!arg3) {
77614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77615     return ;
77616   }
77617   {
77618     try {
77619       (arg1)->DeleteRow(arg2,*arg3);
77620     } catch (std::out_of_range& e) {
77621       {
77622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77623       };
77624     } catch (std::exception& e) {
77625       {
77626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77627       };
77628     } catch (Dali::DaliException e) {
77629       {
77630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77631       };
77632     } catch (...) {
77633       {
77634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77635       };
77636     }
77637   }
77638
77639 }
77640
77641
77642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
77643   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77644   unsigned int arg2 ;
77645
77646   arg1 = (Dali::Toolkit::TableView *)jarg1;
77647   arg2 = (unsigned int)jarg2;
77648   {
77649     try {
77650       (arg1)->InsertColumn(arg2);
77651     } catch (std::out_of_range& e) {
77652       {
77653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77654       };
77655     } catch (std::exception& e) {
77656       {
77657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77658       };
77659     } catch (Dali::DaliException e) {
77660       {
77661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77662       };
77663     } catch (...) {
77664       {
77665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77666       };
77667     }
77668   }
77669
77670 }
77671
77672
77673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
77674   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77675   unsigned int arg2 ;
77676
77677   arg1 = (Dali::Toolkit::TableView *)jarg1;
77678   arg2 = (unsigned int)jarg2;
77679   {
77680     try {
77681       (arg1)->DeleteColumn(arg2);
77682     } catch (std::out_of_range& e) {
77683       {
77684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77685       };
77686     } catch (std::exception& e) {
77687       {
77688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77689       };
77690     } catch (Dali::DaliException e) {
77691       {
77692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77693       };
77694     } catch (...) {
77695       {
77696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77697       };
77698     }
77699   }
77700
77701 }
77702
77703
77704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77705   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77706   unsigned int arg2 ;
77707   std::vector< Dali::Actor > *arg3 = 0 ;
77708
77709   arg1 = (Dali::Toolkit::TableView *)jarg1;
77710   arg2 = (unsigned int)jarg2;
77711   arg3 = (std::vector< Dali::Actor > *)jarg3;
77712   if (!arg3) {
77713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77714     return ;
77715   }
77716   {
77717     try {
77718       (arg1)->DeleteColumn(arg2,*arg3);
77719     } catch (std::out_of_range& e) {
77720       {
77721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77722       };
77723     } catch (std::exception& e) {
77724       {
77725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77726       };
77727     } catch (Dali::DaliException e) {
77728       {
77729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77730       };
77731     } catch (...) {
77732       {
77733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77734       };
77735     }
77736   }
77737
77738 }
77739
77740
77741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
77742   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77743   unsigned int arg2 ;
77744   unsigned int arg3 ;
77745
77746   arg1 = (Dali::Toolkit::TableView *)jarg1;
77747   arg2 = (unsigned int)jarg2;
77748   arg3 = (unsigned int)jarg3;
77749   {
77750     try {
77751       (arg1)->Resize(arg2,arg3);
77752     } catch (std::out_of_range& e) {
77753       {
77754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77755       };
77756     } catch (std::exception& e) {
77757       {
77758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77759       };
77760     } catch (Dali::DaliException e) {
77761       {
77762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77763       };
77764     } catch (...) {
77765       {
77766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77767       };
77768     }
77769   }
77770
77771 }
77772
77773
77774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
77775   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77776   unsigned int arg2 ;
77777   unsigned int arg3 ;
77778   std::vector< Dali::Actor > *arg4 = 0 ;
77779
77780   arg1 = (Dali::Toolkit::TableView *)jarg1;
77781   arg2 = (unsigned int)jarg2;
77782   arg3 = (unsigned int)jarg3;
77783   arg4 = (std::vector< Dali::Actor > *)jarg4;
77784   if (!arg4) {
77785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77786     return ;
77787   }
77788   {
77789     try {
77790       (arg1)->Resize(arg2,arg3,*arg4);
77791     } catch (std::out_of_range& e) {
77792       {
77793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77794       };
77795     } catch (std::exception& e) {
77796       {
77797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77798       };
77799     } catch (Dali::DaliException e) {
77800       {
77801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77802       };
77803     } catch (...) {
77804       {
77805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77806       };
77807     }
77808   }
77809
77810 }
77811
77812
77813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
77814   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77815   Dali::Size arg2 ;
77816   Dali::Size *argp2 ;
77817
77818   arg1 = (Dali::Toolkit::TableView *)jarg1;
77819   argp2 = (Dali::Size *)jarg2;
77820   if (!argp2) {
77821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
77822     return ;
77823   }
77824   arg2 = *argp2;
77825   {
77826     try {
77827       (arg1)->SetCellPadding(arg2);
77828     } catch (std::out_of_range& e) {
77829       {
77830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77831       };
77832     } catch (std::exception& e) {
77833       {
77834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77835       };
77836     } catch (Dali::DaliException e) {
77837       {
77838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77839       };
77840     } catch (...) {
77841       {
77842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77843       };
77844     }
77845   }
77846
77847 }
77848
77849
77850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
77851   void * jresult ;
77852   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77853   Dali::Size result;
77854
77855   arg1 = (Dali::Toolkit::TableView *)jarg1;
77856   {
77857     try {
77858       result = (arg1)->GetCellPadding();
77859     } catch (std::out_of_range& e) {
77860       {
77861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77862       };
77863     } catch (std::exception& e) {
77864       {
77865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77866       };
77867     } catch (Dali::DaliException e) {
77868       {
77869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77870       };
77871     } catch (...) {
77872       {
77873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77874       };
77875     }
77876   }
77877
77878   jresult = new Dali::Size((const Dali::Size &)result);
77879   return jresult;
77880 }
77881
77882
77883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
77884   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77885   unsigned int arg2 ;
77886
77887   arg1 = (Dali::Toolkit::TableView *)jarg1;
77888   arg2 = (unsigned int)jarg2;
77889   {
77890     try {
77891       (arg1)->SetFitHeight(arg2);
77892     } catch (std::out_of_range& e) {
77893       {
77894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77895       };
77896     } catch (std::exception& e) {
77897       {
77898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77899       };
77900     } catch (Dali::DaliException e) {
77901       {
77902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77903       };
77904     } catch (...) {
77905       {
77906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77907       };
77908     }
77909   }
77910
77911 }
77912
77913
77914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
77915   unsigned int jresult ;
77916   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77917   unsigned int arg2 ;
77918   bool result;
77919
77920   arg1 = (Dali::Toolkit::TableView *)jarg1;
77921   arg2 = (unsigned int)jarg2;
77922   {
77923     try {
77924       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
77925     } catch (std::out_of_range& e) {
77926       {
77927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77928       };
77929     } catch (std::exception& e) {
77930       {
77931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77932       };
77933     } catch (Dali::DaliException e) {
77934       {
77935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77936       };
77937     } catch (...) {
77938       {
77939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77940       };
77941     }
77942   }
77943
77944   jresult = result;
77945   return jresult;
77946 }
77947
77948
77949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
77950   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77951   unsigned int arg2 ;
77952
77953   arg1 = (Dali::Toolkit::TableView *)jarg1;
77954   arg2 = (unsigned int)jarg2;
77955   {
77956     try {
77957       (arg1)->SetFitWidth(arg2);
77958     } catch (std::out_of_range& e) {
77959       {
77960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77961       };
77962     } catch (std::exception& e) {
77963       {
77964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77965       };
77966     } catch (Dali::DaliException e) {
77967       {
77968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77969       };
77970     } catch (...) {
77971       {
77972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77973       };
77974     }
77975   }
77976
77977 }
77978
77979
77980 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
77981   unsigned int jresult ;
77982   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77983   unsigned int arg2 ;
77984   bool result;
77985
77986   arg1 = (Dali::Toolkit::TableView *)jarg1;
77987   arg2 = (unsigned int)jarg2;
77988   {
77989     try {
77990       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
77991     } catch (std::out_of_range& e) {
77992       {
77993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77994       };
77995     } catch (std::exception& e) {
77996       {
77997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77998       };
77999     } catch (Dali::DaliException e) {
78000       {
78001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78002       };
78003     } catch (...) {
78004       {
78005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78006       };
78007     }
78008   }
78009
78010   jresult = result;
78011   return jresult;
78012 }
78013
78014
78015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78016   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78017   unsigned int arg2 ;
78018   float arg3 ;
78019
78020   arg1 = (Dali::Toolkit::TableView *)jarg1;
78021   arg2 = (unsigned int)jarg2;
78022   arg3 = (float)jarg3;
78023   {
78024     try {
78025       (arg1)->SetFixedHeight(arg2,arg3);
78026     } catch (std::out_of_range& e) {
78027       {
78028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78029       };
78030     } catch (std::exception& e) {
78031       {
78032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78033       };
78034     } catch (Dali::DaliException e) {
78035       {
78036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78037       };
78038     } catch (...) {
78039       {
78040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78041       };
78042     }
78043   }
78044
78045 }
78046
78047
78048 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
78049   float jresult ;
78050   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78051   unsigned int arg2 ;
78052   float result;
78053
78054   arg1 = (Dali::Toolkit::TableView *)jarg1;
78055   arg2 = (unsigned int)jarg2;
78056   {
78057     try {
78058       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
78059     } catch (std::out_of_range& e) {
78060       {
78061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78062       };
78063     } catch (std::exception& e) {
78064       {
78065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78066       };
78067     } catch (Dali::DaliException e) {
78068       {
78069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78070       };
78071     } catch (...) {
78072       {
78073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78074       };
78075     }
78076   }
78077
78078   jresult = result;
78079   return jresult;
78080 }
78081
78082
78083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78084   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78085   unsigned int arg2 ;
78086   float arg3 ;
78087
78088   arg1 = (Dali::Toolkit::TableView *)jarg1;
78089   arg2 = (unsigned int)jarg2;
78090   arg3 = (float)jarg3;
78091   {
78092     try {
78093       (arg1)->SetRelativeHeight(arg2,arg3);
78094     } catch (std::out_of_range& e) {
78095       {
78096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78097       };
78098     } catch (std::exception& e) {
78099       {
78100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78101       };
78102     } catch (Dali::DaliException e) {
78103       {
78104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78105       };
78106     } catch (...) {
78107       {
78108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78109       };
78110     }
78111   }
78112
78113 }
78114
78115
78116 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
78117   float jresult ;
78118   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78119   unsigned int arg2 ;
78120   float result;
78121
78122   arg1 = (Dali::Toolkit::TableView *)jarg1;
78123   arg2 = (unsigned int)jarg2;
78124   {
78125     try {
78126       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
78127     } catch (std::out_of_range& e) {
78128       {
78129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78130       };
78131     } catch (std::exception& e) {
78132       {
78133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78134       };
78135     } catch (Dali::DaliException e) {
78136       {
78137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78138       };
78139     } catch (...) {
78140       {
78141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78142       };
78143     }
78144   }
78145
78146   jresult = result;
78147   return jresult;
78148 }
78149
78150
78151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78152   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78153   unsigned int arg2 ;
78154   float arg3 ;
78155
78156   arg1 = (Dali::Toolkit::TableView *)jarg1;
78157   arg2 = (unsigned int)jarg2;
78158   arg3 = (float)jarg3;
78159   {
78160     try {
78161       (arg1)->SetFixedWidth(arg2,arg3);
78162     } catch (std::out_of_range& e) {
78163       {
78164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78165       };
78166     } catch (std::exception& e) {
78167       {
78168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78169       };
78170     } catch (Dali::DaliException e) {
78171       {
78172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78173       };
78174     } catch (...) {
78175       {
78176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78177       };
78178     }
78179   }
78180
78181 }
78182
78183
78184 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
78185   float jresult ;
78186   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78187   unsigned int arg2 ;
78188   float result;
78189
78190   arg1 = (Dali::Toolkit::TableView *)jarg1;
78191   arg2 = (unsigned int)jarg2;
78192   {
78193     try {
78194       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
78195     } catch (std::out_of_range& e) {
78196       {
78197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78198       };
78199     } catch (std::exception& e) {
78200       {
78201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78202       };
78203     } catch (Dali::DaliException e) {
78204       {
78205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78206       };
78207     } catch (...) {
78208       {
78209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78210       };
78211     }
78212   }
78213
78214   jresult = result;
78215   return jresult;
78216 }
78217
78218
78219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78220   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78221   unsigned int arg2 ;
78222   float arg3 ;
78223
78224   arg1 = (Dali::Toolkit::TableView *)jarg1;
78225   arg2 = (unsigned int)jarg2;
78226   arg3 = (float)jarg3;
78227   {
78228     try {
78229       (arg1)->SetRelativeWidth(arg2,arg3);
78230     } catch (std::out_of_range& e) {
78231       {
78232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78233       };
78234     } catch (std::exception& e) {
78235       {
78236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78237       };
78238     } catch (Dali::DaliException e) {
78239       {
78240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78241       };
78242     } catch (...) {
78243       {
78244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78245       };
78246     }
78247   }
78248
78249 }
78250
78251
78252 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
78253   float jresult ;
78254   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78255   unsigned int arg2 ;
78256   float result;
78257
78258   arg1 = (Dali::Toolkit::TableView *)jarg1;
78259   arg2 = (unsigned int)jarg2;
78260   {
78261     try {
78262       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
78263     } catch (std::out_of_range& e) {
78264       {
78265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78266       };
78267     } catch (std::exception& e) {
78268       {
78269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78270       };
78271     } catch (Dali::DaliException e) {
78272       {
78273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78274       };
78275     } catch (...) {
78276       {
78277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78278       };
78279     }
78280   }
78281
78282   jresult = result;
78283   return jresult;
78284 }
78285
78286
78287 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
78288   unsigned int jresult ;
78289   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78290   unsigned int result;
78291
78292   arg1 = (Dali::Toolkit::TableView *)jarg1;
78293   {
78294     try {
78295       result = (unsigned int)(arg1)->GetRows();
78296     } catch (std::out_of_range& e) {
78297       {
78298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78299       };
78300     } catch (std::exception& e) {
78301       {
78302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78303       };
78304     } catch (Dali::DaliException e) {
78305       {
78306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78307       };
78308     } catch (...) {
78309       {
78310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78311       };
78312     }
78313   }
78314
78315   jresult = result;
78316   return jresult;
78317 }
78318
78319
78320 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
78321   unsigned int jresult ;
78322   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78323   unsigned int result;
78324
78325   arg1 = (Dali::Toolkit::TableView *)jarg1;
78326   {
78327     try {
78328       result = (unsigned int)(arg1)->GetColumns();
78329     } catch (std::out_of_range& e) {
78330       {
78331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78332       };
78333     } catch (std::exception& e) {
78334       {
78335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78336       };
78337     } catch (Dali::DaliException e) {
78338       {
78339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78340       };
78341     } catch (...) {
78342       {
78343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78344       };
78345     }
78346   }
78347
78348   jresult = result;
78349   return jresult;
78350 }
78351
78352
78353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
78354   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78355   Dali::Toolkit::TableView::CellPosition arg2 ;
78356   Dali::HorizontalAlignment::Type arg3 ;
78357   Dali::VerticalAlignment::Type arg4 ;
78358   Dali::Toolkit::TableView::CellPosition *argp2 ;
78359
78360   arg1 = (Dali::Toolkit::TableView *)jarg1;
78361   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
78362   if (!argp2) {
78363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
78364     return ;
78365   }
78366   arg2 = *argp2;
78367   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
78368   arg4 = (Dali::VerticalAlignment::Type)jarg4;
78369   {
78370     try {
78371       (arg1)->SetCellAlignment(arg2,arg3,arg4);
78372     } catch (std::out_of_range& e) {
78373       {
78374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78375       };
78376     } catch (std::exception& e) {
78377       {
78378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78379       };
78380     } catch (Dali::DaliException e) {
78381       {
78382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78383       };
78384     } catch (...) {
78385       {
78386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78387       };
78388     }
78389   }
78390
78391 }
78392
78393
78394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
78395   unsigned int jresult ;
78396   unsigned int result;
78397
78398   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
78399   jresult = result;
78400   return jresult;
78401 }
78402
78403
78404 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78405   int jresult ;
78406   int result;
78407
78408   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78409   jresult = (int)result;
78410   return jresult;
78411 }
78412
78413
78414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78415   int jresult ;
78416   int result;
78417
78418   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78419   jresult = (int)result;
78420   return jresult;
78421 }
78422
78423
78424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78425   int jresult ;
78426   int result;
78427
78428   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78429   jresult = (int)result;
78430   return jresult;
78431 }
78432
78433
78434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78435   int jresult ;
78436   int result;
78437
78438   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78439   jresult = (int)result;
78440   return jresult;
78441 }
78442
78443
78444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78445   int jresult ;
78446   int result;
78447
78448   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78449   jresult = (int)result;
78450   return jresult;
78451 }
78452
78453
78454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78455   int jresult ;
78456   int result;
78457
78458   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78459   jresult = (int)result;
78460   return jresult;
78461 }
78462
78463
78464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78465   int jresult ;
78466   int result;
78467
78468   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78469   jresult = (int)result;
78470   return jresult;
78471 }
78472
78473
78474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78475   int jresult ;
78476   int result;
78477
78478   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78479   jresult = (int)result;
78480   return jresult;
78481 }
78482
78483
78484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78485   int jresult ;
78486   int result;
78487
78488   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78489   jresult = (int)result;
78490   return jresult;
78491 }
78492
78493
78494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78495   int jresult ;
78496   int result;
78497
78498   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78499   jresult = (int)result;
78500   return jresult;
78501 }
78502
78503
78504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78505   int jresult ;
78506   int result;
78507
78508   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78509   jresult = (int)result;
78510   return jresult;
78511 }
78512
78513
78514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78515   int jresult ;
78516   int result;
78517
78518   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78519   jresult = (int)result;
78520   return jresult;
78521 }
78522
78523
78524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78525   int jresult ;
78526   int result;
78527
78528   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78529   jresult = (int)result;
78530   return jresult;
78531 }
78532
78533
78534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78535   int jresult ;
78536   int result;
78537
78538   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78539   jresult = (int)result;
78540   return jresult;
78541 }
78542
78543
78544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78545   int jresult ;
78546   int result;
78547
78548   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78549   jresult = (int)result;
78550   return jresult;
78551 }
78552
78553
78554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78555   int jresult ;
78556   int result;
78557
78558   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78559   jresult = (int)result;
78560   return jresult;
78561 }
78562
78563
78564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78565   int jresult ;
78566   int result;
78567
78568   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78569   jresult = (int)result;
78570   return jresult;
78571 }
78572
78573
78574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78575   int jresult ;
78576   int result;
78577
78578   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78579   jresult = (int)result;
78580   return jresult;
78581 }
78582
78583
78584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78585   void * jresult ;
78586   Dali::Toolkit::TextLabel::Property *result = 0 ;
78587
78588   {
78589     try {
78590       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78591     } catch (std::out_of_range& e) {
78592       {
78593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78594       };
78595     } catch (std::exception& e) {
78596       {
78597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78598       };
78599     } catch (Dali::DaliException e) {
78600       {
78601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78602       };
78603     } catch (...) {
78604       {
78605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78606       };
78607     }
78608   }
78609
78610   jresult = (void *)result;
78611   return jresult;
78612 }
78613
78614
78615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78616   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78617
78618   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78619   {
78620     try {
78621       delete arg1;
78622     } catch (std::out_of_range& e) {
78623       {
78624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78625       };
78626     } catch (std::exception& e) {
78627       {
78628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78629       };
78630     } catch (Dali::DaliException e) {
78631       {
78632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78633       };
78634     } catch (...) {
78635       {
78636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78637       };
78638     }
78639   }
78640
78641 }
78642
78643
78644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78645   void * jresult ;
78646   Dali::Toolkit::TextLabel result;
78647
78648   {
78649     try {
78650       result = Dali::Toolkit::TextLabel::New();
78651     } catch (std::out_of_range& e) {
78652       {
78653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78654       };
78655     } catch (std::exception& e) {
78656       {
78657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78658       };
78659     } catch (Dali::DaliException e) {
78660       {
78661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78662       };
78663     } catch (...) {
78664       {
78665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78666       };
78667     }
78668   }
78669
78670   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78671   return jresult;
78672 }
78673
78674
78675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78676   void * jresult ;
78677   std::string *arg1 = 0 ;
78678   Dali::Toolkit::TextLabel result;
78679
78680   if (!jarg1) {
78681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78682     return 0;
78683   }
78684   std::string arg1_str(jarg1);
78685   arg1 = &arg1_str;
78686   {
78687     try {
78688       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
78689     } catch (std::out_of_range& e) {
78690       {
78691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78692       };
78693     } catch (std::exception& e) {
78694       {
78695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78696       };
78697     } catch (Dali::DaliException e) {
78698       {
78699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78700       };
78701     } catch (...) {
78702       {
78703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78704       };
78705     }
78706   }
78707
78708   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78709
78710   //argout typemap for const std::string&
78711
78712   return jresult;
78713 }
78714
78715
78716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78717   void * jresult ;
78718   Dali::Toolkit::TextLabel *result = 0 ;
78719
78720   {
78721     try {
78722       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78723     } catch (std::out_of_range& e) {
78724       {
78725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78726       };
78727     } catch (std::exception& e) {
78728       {
78729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78730       };
78731     } catch (Dali::DaliException e) {
78732       {
78733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78734       };
78735     } catch (...) {
78736       {
78737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78738       };
78739     }
78740   }
78741
78742   jresult = (void *)result;
78743   return jresult;
78744 }
78745
78746
78747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78748   void * jresult ;
78749   Dali::Toolkit::TextLabel *arg1 = 0 ;
78750   Dali::Toolkit::TextLabel *result = 0 ;
78751
78752   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78753   if (!arg1) {
78754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78755     return 0;
78756   }
78757   {
78758     try {
78759       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78760     } catch (std::out_of_range& e) {
78761       {
78762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78763       };
78764     } catch (std::exception& e) {
78765       {
78766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78767       };
78768     } catch (Dali::DaliException e) {
78769       {
78770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78771       };
78772     } catch (...) {
78773       {
78774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78775       };
78776     }
78777   }
78778
78779   jresult = (void *)result;
78780   return jresult;
78781 }
78782
78783
78784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78785   void * jresult ;
78786   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78787   Dali::Toolkit::TextLabel *arg2 = 0 ;
78788   Dali::Toolkit::TextLabel *result = 0 ;
78789
78790   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78791   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78792   if (!arg2) {
78793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78794     return 0;
78795   }
78796   {
78797     try {
78798       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
78799     } catch (std::out_of_range& e) {
78800       {
78801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78802       };
78803     } catch (std::exception& e) {
78804       {
78805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78806       };
78807     } catch (Dali::DaliException e) {
78808       {
78809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78810       };
78811     } catch (...) {
78812       {
78813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78814       };
78815     }
78816   }
78817
78818   jresult = (void *)result;
78819   return jresult;
78820 }
78821
78822
78823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
78824   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78825
78826   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78827   {
78828     try {
78829       delete arg1;
78830     } catch (std::out_of_range& e) {
78831       {
78832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78833       };
78834     } catch (std::exception& e) {
78835       {
78836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78837       };
78838     } catch (Dali::DaliException e) {
78839       {
78840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78841       };
78842     } catch (...) {
78843       {
78844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78845       };
78846     }
78847   }
78848
78849 }
78850
78851
78852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
78853   void * jresult ;
78854   Dali::BaseHandle arg1 ;
78855   Dali::BaseHandle *argp1 ;
78856   Dali::Toolkit::TextLabel result;
78857
78858   argp1 = (Dali::BaseHandle *)jarg1;
78859   if (!argp1) {
78860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78861     return 0;
78862   }
78863   arg1 = *argp1;
78864   {
78865     try {
78866       result = Dali::Toolkit::TextLabel::DownCast(arg1);
78867     } catch (std::out_of_range& e) {
78868       {
78869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78870       };
78871     } catch (std::exception& e) {
78872       {
78873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78874       };
78875     } catch (Dali::DaliException e) {
78876       {
78877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78878       };
78879     } catch (...) {
78880       {
78881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78882       };
78883     }
78884   }
78885
78886   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78887   return jresult;
78888 }
78889
78890
78891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
78892   void * jresult ;
78893   Dali::Toolkit::AccessibilityManager *result = 0 ;
78894
78895   {
78896     try {
78897       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
78898     } catch (std::out_of_range& e) {
78899       {
78900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78901       };
78902     } catch (std::exception& e) {
78903       {
78904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78905       };
78906     } catch (Dali::DaliException e) {
78907       {
78908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78909       };
78910     } catch (...) {
78911       {
78912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78913       };
78914     }
78915   }
78916
78917   jresult = (void *)result;
78918   return jresult;
78919 }
78920
78921
78922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
78923   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78924
78925   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78926   {
78927     try {
78928       delete arg1;
78929     } catch (std::out_of_range& e) {
78930       {
78931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78932       };
78933     } catch (std::exception& e) {
78934       {
78935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78936       };
78937     } catch (Dali::DaliException e) {
78938       {
78939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78940       };
78941     } catch (...) {
78942       {
78943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78944       };
78945     }
78946   }
78947
78948 }
78949
78950
78951 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
78952   void * jresult ;
78953   Dali::Toolkit::AccessibilityManager result;
78954
78955   {
78956     try {
78957       result = Dali::Toolkit::AccessibilityManager::Get();
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 = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
78978   return jresult;
78979 }
78980
78981
78982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
78983   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78984   Dali::Actor arg2 ;
78985   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
78986   std::string *arg4 = 0 ;
78987   Dali::Actor *argp2 ;
78988
78989   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78990   argp2 = (Dali::Actor *)jarg2;
78991   if (!argp2) {
78992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78993     return ;
78994   }
78995   arg2 = *argp2;
78996   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
78997   if (!jarg4) {
78998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78999     return ;
79000   }
79001   std::string arg4_str(jarg4);
79002   arg4 = &arg4_str;
79003   {
79004     try {
79005       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79006     } catch (std::out_of_range& e) {
79007       {
79008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79009       };
79010     } catch (std::exception& e) {
79011       {
79012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79013       };
79014     } catch (Dali::DaliException e) {
79015       {
79016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79017       };
79018     } catch (...) {
79019       {
79020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79021       };
79022     }
79023   }
79024
79025
79026   //argout typemap for const std::string&
79027
79028 }
79029
79030
79031 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79032   char * jresult ;
79033   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79034   Dali::Actor arg2 ;
79035   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79036   Dali::Actor *argp2 ;
79037   std::string result;
79038
79039   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79040   argp2 = (Dali::Actor *)jarg2;
79041   if (!argp2) {
79042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79043     return 0;
79044   }
79045   arg2 = *argp2;
79046   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79047   {
79048     try {
79049       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79050     } catch (std::out_of_range& e) {
79051       {
79052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79053       };
79054     } catch (std::exception& e) {
79055       {
79056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79057       };
79058     } catch (Dali::DaliException e) {
79059       {
79060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79061       };
79062     } catch (...) {
79063       {
79064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79065       };
79066     }
79067   }
79068
79069   jresult = SWIG_csharp_string_callback((&result)->c_str());
79070   return jresult;
79071 }
79072
79073
79074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79075   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79076   Dali::Actor arg2 ;
79077   unsigned int arg3 ;
79078   Dali::Actor *argp2 ;
79079
79080   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79081   argp2 = (Dali::Actor *)jarg2;
79082   if (!argp2) {
79083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79084     return ;
79085   }
79086   arg2 = *argp2;
79087   arg3 = (unsigned int)jarg3;
79088   {
79089     try {
79090       (arg1)->SetFocusOrder(arg2,arg3);
79091     } catch (std::out_of_range& e) {
79092       {
79093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79094       };
79095     } catch (std::exception& e) {
79096       {
79097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79098       };
79099     } catch (Dali::DaliException e) {
79100       {
79101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79102       };
79103     } catch (...) {
79104       {
79105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79106       };
79107     }
79108   }
79109
79110 }
79111
79112
79113 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79114   unsigned int jresult ;
79115   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79116   Dali::Actor arg2 ;
79117   Dali::Actor *argp2 ;
79118   unsigned int result;
79119
79120   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79121   argp2 = (Dali::Actor *)jarg2;
79122   if (!argp2) {
79123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79124     return 0;
79125   }
79126   arg2 = *argp2;
79127   {
79128     try {
79129       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79130     } catch (std::out_of_range& e) {
79131       {
79132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79133       };
79134     } catch (std::exception& e) {
79135       {
79136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79137       };
79138     } catch (Dali::DaliException e) {
79139       {
79140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79141       };
79142     } catch (...) {
79143       {
79144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79145       };
79146     }
79147   }
79148
79149   jresult = result;
79150   return jresult;
79151 }
79152
79153
79154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79155   unsigned int jresult ;
79156   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79157   unsigned int result;
79158
79159   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79160   {
79161     try {
79162       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79163     } catch (std::out_of_range& e) {
79164       {
79165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79166       };
79167     } catch (std::exception& e) {
79168       {
79169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79170       };
79171     } catch (Dali::DaliException e) {
79172       {
79173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79174       };
79175     } catch (...) {
79176       {
79177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79178       };
79179     }
79180   }
79181
79182   jresult = result;
79183   return jresult;
79184 }
79185
79186
79187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79188   void * jresult ;
79189   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79190   unsigned int arg2 ;
79191   Dali::Actor result;
79192
79193   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79194   arg2 = (unsigned int)jarg2;
79195   {
79196     try {
79197       result = (arg1)->GetActorByFocusOrder(arg2);
79198     } catch (std::out_of_range& e) {
79199       {
79200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79201       };
79202     } catch (std::exception& e) {
79203       {
79204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79205       };
79206     } catch (Dali::DaliException e) {
79207       {
79208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79209       };
79210     } catch (...) {
79211       {
79212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79213       };
79214     }
79215   }
79216
79217   jresult = new Dali::Actor((const Dali::Actor &)result);
79218   return jresult;
79219 }
79220
79221
79222 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79223   unsigned int jresult ;
79224   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79225   Dali::Actor arg2 ;
79226   Dali::Actor *argp2 ;
79227   bool result;
79228
79229   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79230   argp2 = (Dali::Actor *)jarg2;
79231   if (!argp2) {
79232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79233     return 0;
79234   }
79235   arg2 = *argp2;
79236   {
79237     try {
79238       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79239     } catch (std::out_of_range& e) {
79240       {
79241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79242       };
79243     } catch (std::exception& e) {
79244       {
79245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79246       };
79247     } catch (Dali::DaliException e) {
79248       {
79249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79250       };
79251     } catch (...) {
79252       {
79253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79254       };
79255     }
79256   }
79257
79258   jresult = result;
79259   return jresult;
79260 }
79261
79262
79263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79264   void * jresult ;
79265   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79266   Dali::Actor result;
79267
79268   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79269   {
79270     try {
79271       result = (arg1)->GetCurrentFocusActor();
79272     } catch (std::out_of_range& e) {
79273       {
79274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79275       };
79276     } catch (std::exception& e) {
79277       {
79278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79279       };
79280     } catch (Dali::DaliException e) {
79281       {
79282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79283       };
79284     } catch (...) {
79285       {
79286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79287       };
79288     }
79289   }
79290
79291   jresult = new Dali::Actor((const Dali::Actor &)result);
79292   return jresult;
79293 }
79294
79295
79296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79297   void * jresult ;
79298   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79299   Dali::Actor result;
79300
79301   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79302   {
79303     try {
79304       result = (arg1)->GetCurrentFocusGroup();
79305     } catch (std::out_of_range& e) {
79306       {
79307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79308       };
79309     } catch (std::exception& e) {
79310       {
79311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79312       };
79313     } catch (Dali::DaliException e) {
79314       {
79315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79316       };
79317     } catch (...) {
79318       {
79319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79320       };
79321     }
79322   }
79323
79324   jresult = new Dali::Actor((const Dali::Actor &)result);
79325   return jresult;
79326 }
79327
79328
79329 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79330   unsigned int jresult ;
79331   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79332   unsigned int result;
79333
79334   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79335   {
79336     try {
79337       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79338     } catch (std::out_of_range& e) {
79339       {
79340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79341       };
79342     } catch (std::exception& e) {
79343       {
79344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79345       };
79346     } catch (Dali::DaliException e) {
79347       {
79348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79349       };
79350     } catch (...) {
79351       {
79352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79353       };
79354     }
79355   }
79356
79357   jresult = result;
79358   return jresult;
79359 }
79360
79361
79362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79363   unsigned int jresult ;
79364   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79365   bool result;
79366
79367   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79368   {
79369     try {
79370       result = (bool)(arg1)->MoveFocusForward();
79371     } catch (std::out_of_range& e) {
79372       {
79373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79374       };
79375     } catch (std::exception& e) {
79376       {
79377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79378       };
79379     } catch (Dali::DaliException e) {
79380       {
79381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79382       };
79383     } catch (...) {
79384       {
79385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79386       };
79387     }
79388   }
79389
79390   jresult = result;
79391   return jresult;
79392 }
79393
79394
79395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79396   unsigned int jresult ;
79397   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79398   bool result;
79399
79400   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79401   {
79402     try {
79403       result = (bool)(arg1)->MoveFocusBackward();
79404     } catch (std::out_of_range& e) {
79405       {
79406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79407       };
79408     } catch (std::exception& e) {
79409       {
79410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79411       };
79412     } catch (Dali::DaliException e) {
79413       {
79414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79415       };
79416     } catch (...) {
79417       {
79418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79419       };
79420     }
79421   }
79422
79423   jresult = result;
79424   return jresult;
79425 }
79426
79427
79428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79429   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79430
79431   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79432   {
79433     try {
79434       (arg1)->ClearFocus();
79435     } catch (std::out_of_range& e) {
79436       {
79437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79438       };
79439     } catch (std::exception& e) {
79440       {
79441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79442       };
79443     } catch (Dali::DaliException e) {
79444       {
79445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79446       };
79447     } catch (...) {
79448       {
79449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79450       };
79451     }
79452   }
79453
79454 }
79455
79456
79457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79458   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79459
79460   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79461   {
79462     try {
79463       (arg1)->Reset();
79464     } catch (std::out_of_range& e) {
79465       {
79466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79467       };
79468     } catch (std::exception& e) {
79469       {
79470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79471       };
79472     } catch (Dali::DaliException e) {
79473       {
79474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79475       };
79476     } catch (...) {
79477       {
79478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79479       };
79480     }
79481   }
79482
79483 }
79484
79485
79486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79487   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79488   Dali::Actor arg2 ;
79489   bool arg3 ;
79490   Dali::Actor *argp2 ;
79491
79492   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79493   argp2 = (Dali::Actor *)jarg2;
79494   if (!argp2) {
79495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79496     return ;
79497   }
79498   arg2 = *argp2;
79499   arg3 = jarg3 ? true : false;
79500   {
79501     try {
79502       (arg1)->SetFocusGroup(arg2,arg3);
79503     } catch (std::out_of_range& e) {
79504       {
79505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79506       };
79507     } catch (std::exception& e) {
79508       {
79509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79510       };
79511     } catch (Dali::DaliException e) {
79512       {
79513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79514       };
79515     } catch (...) {
79516       {
79517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79518       };
79519     }
79520   }
79521
79522 }
79523
79524
79525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79526   unsigned int jresult ;
79527   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79528   Dali::Actor arg2 ;
79529   Dali::Actor *argp2 ;
79530   bool result;
79531
79532   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79533   argp2 = (Dali::Actor *)jarg2;
79534   if (!argp2) {
79535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79536     return 0;
79537   }
79538   arg2 = *argp2;
79539   {
79540     try {
79541       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79542     } catch (std::out_of_range& e) {
79543       {
79544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79545       };
79546     } catch (std::exception& e) {
79547       {
79548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79549       };
79550     } catch (Dali::DaliException e) {
79551       {
79552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79553       };
79554     } catch (...) {
79555       {
79556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79557       };
79558     }
79559   }
79560
79561   jresult = result;
79562   return jresult;
79563 }
79564
79565
79566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79567   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79568   bool arg2 ;
79569
79570   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79571   arg2 = jarg2 ? true : false;
79572   {
79573     try {
79574       (arg1)->SetGroupMode(arg2);
79575     } catch (std::out_of_range& e) {
79576       {
79577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79578       };
79579     } catch (std::exception& e) {
79580       {
79581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79582       };
79583     } catch (Dali::DaliException e) {
79584       {
79585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79586       };
79587     } catch (...) {
79588       {
79589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79590       };
79591     }
79592   }
79593
79594 }
79595
79596
79597 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79598   unsigned int jresult ;
79599   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79600   bool result;
79601
79602   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79603   {
79604     try {
79605       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79606     } catch (std::out_of_range& e) {
79607       {
79608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79609       };
79610     } catch (std::exception& e) {
79611       {
79612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79613       };
79614     } catch (Dali::DaliException e) {
79615       {
79616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79617       };
79618     } catch (...) {
79619       {
79620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79621       };
79622     }
79623   }
79624
79625   jresult = result;
79626   return jresult;
79627 }
79628
79629
79630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79631   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79632   bool arg2 ;
79633
79634   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79635   arg2 = jarg2 ? true : false;
79636   {
79637     try {
79638       (arg1)->SetWrapMode(arg2);
79639     } catch (std::out_of_range& e) {
79640       {
79641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79642       };
79643     } catch (std::exception& e) {
79644       {
79645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79646       };
79647     } catch (Dali::DaliException e) {
79648       {
79649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79650       };
79651     } catch (...) {
79652       {
79653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79654       };
79655     }
79656   }
79657
79658 }
79659
79660
79661 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
79662   unsigned int jresult ;
79663   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79664   bool result;
79665
79666   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79667   {
79668     try {
79669       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
79670     } catch (std::out_of_range& e) {
79671       {
79672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79673       };
79674     } catch (std::exception& e) {
79675       {
79676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79677       };
79678     } catch (Dali::DaliException e) {
79679       {
79680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79681       };
79682     } catch (...) {
79683       {
79684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79685       };
79686     }
79687   }
79688
79689   jresult = result;
79690   return jresult;
79691 }
79692
79693
79694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
79695   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79696   Dali::Actor arg2 ;
79697   Dali::Actor *argp2 ;
79698
79699   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79700   argp2 = (Dali::Actor *)jarg2;
79701   if (!argp2) {
79702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79703     return ;
79704   }
79705   arg2 = *argp2;
79706   {
79707     try {
79708       (arg1)->SetFocusIndicatorActor(arg2);
79709     } catch (std::out_of_range& e) {
79710       {
79711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79712       };
79713     } catch (std::exception& e) {
79714       {
79715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79716       };
79717     } catch (Dali::DaliException e) {
79718       {
79719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79720       };
79721     } catch (...) {
79722       {
79723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79724       };
79725     }
79726   }
79727
79728 }
79729
79730
79731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
79732   void * jresult ;
79733   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79734   Dali::Actor result;
79735
79736   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79737   {
79738     try {
79739       result = (arg1)->GetFocusIndicatorActor();
79740     } catch (std::out_of_range& e) {
79741       {
79742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79743       };
79744     } catch (std::exception& e) {
79745       {
79746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79747       };
79748     } catch (Dali::DaliException e) {
79749       {
79750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79751       };
79752     } catch (...) {
79753       {
79754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79755       };
79756     }
79757   }
79758
79759   jresult = new Dali::Actor((const Dali::Actor &)result);
79760   return jresult;
79761 }
79762
79763
79764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
79765   void * jresult ;
79766   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79767   Dali::Actor arg2 ;
79768   Dali::Actor *argp2 ;
79769   Dali::Actor result;
79770
79771   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79772   argp2 = (Dali::Actor *)jarg2;
79773   if (!argp2) {
79774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79775     return 0;
79776   }
79777   arg2 = *argp2;
79778   {
79779     try {
79780       result = (arg1)->GetFocusGroup(arg2);
79781     } catch (std::out_of_range& e) {
79782       {
79783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79784       };
79785     } catch (std::exception& e) {
79786       {
79787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79788       };
79789     } catch (Dali::DaliException e) {
79790       {
79791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79792       };
79793     } catch (...) {
79794       {
79795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79796       };
79797     }
79798   }
79799
79800   jresult = new Dali::Actor((const Dali::Actor &)result);
79801   return jresult;
79802 }
79803
79804
79805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79806   void * jresult ;
79807   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79808   Dali::Vector2 result;
79809
79810   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79811   {
79812     try {
79813       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79814     } catch (std::out_of_range& e) {
79815       {
79816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79817       };
79818     } catch (std::exception& e) {
79819       {
79820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79821       };
79822     } catch (Dali::DaliException e) {
79823       {
79824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79825       };
79826     } catch (...) {
79827       {
79828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79829       };
79830     }
79831   }
79832
79833   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79834   return jresult;
79835 }
79836
79837
79838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
79839   void * jresult ;
79840   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79841   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
79842
79843   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79844   {
79845     try {
79846       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
79847     } catch (std::out_of_range& e) {
79848       {
79849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79850       };
79851     } catch (std::exception& e) {
79852       {
79853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79854       };
79855     } catch (Dali::DaliException e) {
79856       {
79857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79858       };
79859     } catch (...) {
79860       {
79861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79862       };
79863     }
79864   }
79865
79866   jresult = (void *)result;
79867   return jresult;
79868 }
79869
79870
79871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
79872   void * jresult ;
79873   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79874   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
79875
79876   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79877   {
79878     try {
79879       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
79880     } catch (std::out_of_range& e) {
79881       {
79882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79883       };
79884     } catch (std::exception& e) {
79885       {
79886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79887       };
79888     } catch (Dali::DaliException e) {
79889       {
79890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79891       };
79892     } catch (...) {
79893       {
79894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79895       };
79896     }
79897   }
79898
79899   jresult = (void *)result;
79900   return jresult;
79901 }
79902
79903
79904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
79905   void * jresult ;
79906   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79907   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
79908
79909   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79910   {
79911     try {
79912       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
79913     } catch (std::out_of_range& e) {
79914       {
79915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79916       };
79917     } catch (std::exception& e) {
79918       {
79919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79920       };
79921     } catch (Dali::DaliException e) {
79922       {
79923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79924       };
79925     } catch (...) {
79926       {
79927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79928       };
79929     }
79930   }
79931
79932   jresult = (void *)result;
79933   return jresult;
79934 }
79935
79936
79937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
79938   void * jresult ;
79939   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79940   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79941
79942   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79943   {
79944     try {
79945       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
79946     } catch (std::out_of_range& e) {
79947       {
79948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79949       };
79950     } catch (std::exception& e) {
79951       {
79952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79953       };
79954     } catch (Dali::DaliException e) {
79955       {
79956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79957       };
79958     } catch (...) {
79959       {
79960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79961       };
79962     }
79963   }
79964
79965   jresult = (void *)result;
79966   return jresult;
79967 }
79968
79969
79970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
79971   void * jresult ;
79972   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79973   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79974
79975   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79976   {
79977     try {
79978       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
79979     } catch (std::out_of_range& e) {
79980       {
79981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79982       };
79983     } catch (std::exception& e) {
79984       {
79985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79986       };
79987     } catch (Dali::DaliException e) {
79988       {
79989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79990       };
79991     } catch (...) {
79992       {
79993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79994       };
79995     }
79996   }
79997
79998   jresult = (void *)result;
79999   return jresult;
80000 }
80001
80002
80003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80004   void * jresult ;
80005   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80006   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80007
80008   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80009   {
80010     try {
80011       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80012     } catch (std::out_of_range& e) {
80013       {
80014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80015       };
80016     } catch (std::exception& e) {
80017       {
80018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80019       };
80020     } catch (Dali::DaliException e) {
80021       {
80022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80023       };
80024     } catch (...) {
80025       {
80026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80027       };
80028     }
80029   }
80030
80031   jresult = (void *)result;
80032   return jresult;
80033 }
80034
80035
80036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80037   void * jresult ;
80038   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80039   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80040
80041   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80042   {
80043     try {
80044       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80045     } catch (std::out_of_range& e) {
80046       {
80047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80048       };
80049     } catch (std::exception& e) {
80050       {
80051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80052       };
80053     } catch (Dali::DaliException e) {
80054       {
80055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80056       };
80057     } catch (...) {
80058       {
80059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80060       };
80061     }
80062   }
80063
80064   jresult = (void *)result;
80065   return jresult;
80066 }
80067
80068
80069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80070   void * jresult ;
80071   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80072   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80073
80074   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80075   {
80076     try {
80077       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80078     } catch (std::out_of_range& e) {
80079       {
80080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80081       };
80082     } catch (std::exception& e) {
80083       {
80084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80085       };
80086     } catch (Dali::DaliException e) {
80087       {
80088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80089       };
80090     } catch (...) {
80091       {
80092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80093       };
80094     }
80095   }
80096
80097   jresult = (void *)result;
80098   return jresult;
80099 }
80100
80101
80102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80103   void * jresult ;
80104   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80105   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80106
80107   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80108   {
80109     try {
80110       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80111     } catch (std::out_of_range& e) {
80112       {
80113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80114       };
80115     } catch (std::exception& e) {
80116       {
80117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80118       };
80119     } catch (Dali::DaliException e) {
80120       {
80121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80122       };
80123     } catch (...) {
80124       {
80125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80126       };
80127     }
80128   }
80129
80130   jresult = (void *)result;
80131   return jresult;
80132 }
80133
80134
80135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80136   void * jresult ;
80137   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80138   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80139
80140   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80141   {
80142     try {
80143       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80144     } catch (std::out_of_range& e) {
80145       {
80146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80147       };
80148     } catch (std::exception& e) {
80149       {
80150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80151       };
80152     } catch (Dali::DaliException e) {
80153       {
80154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80155       };
80156     } catch (...) {
80157       {
80158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80159       };
80160     }
80161   }
80162
80163   jresult = (void *)result;
80164   return jresult;
80165 }
80166
80167
80168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80169   void * jresult ;
80170   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80171   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80172
80173   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80174   {
80175     try {
80176       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80177     } catch (std::out_of_range& e) {
80178       {
80179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80180       };
80181     } catch (std::exception& e) {
80182       {
80183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80184       };
80185     } catch (Dali::DaliException e) {
80186       {
80187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80188       };
80189     } catch (...) {
80190       {
80191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80192       };
80193     }
80194   }
80195
80196   jresult = (void *)result;
80197   return jresult;
80198 }
80199
80200
80201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80202   void * jresult ;
80203   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80204   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80205
80206   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80207   {
80208     try {
80209       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80210     } catch (std::out_of_range& e) {
80211       {
80212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80213       };
80214     } catch (std::exception& e) {
80215       {
80216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80217       };
80218     } catch (Dali::DaliException e) {
80219       {
80220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80221       };
80222     } catch (...) {
80223       {
80224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80225       };
80226     }
80227   }
80228
80229   jresult = (void *)result;
80230   return jresult;
80231 }
80232
80233
80234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80235   void * jresult ;
80236   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80237   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80238
80239   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80240   {
80241     try {
80242       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80243     } catch (std::out_of_range& e) {
80244       {
80245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80246       };
80247     } catch (std::exception& e) {
80248       {
80249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80250       };
80251     } catch (Dali::DaliException e) {
80252       {
80253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80254       };
80255     } catch (...) {
80256       {
80257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80258       };
80259     }
80260   }
80261
80262   jresult = (void *)result;
80263   return jresult;
80264 }
80265
80266
80267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80268   void * jresult ;
80269   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80270   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80271
80272   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80273   {
80274     try {
80275       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80276     } catch (std::out_of_range& e) {
80277       {
80278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80279       };
80280     } catch (std::exception& e) {
80281       {
80282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80283       };
80284     } catch (Dali::DaliException e) {
80285       {
80286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80287       };
80288     } catch (...) {
80289       {
80290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80291       };
80292     }
80293   }
80294
80295   jresult = (void *)result;
80296   return jresult;
80297 }
80298
80299
80300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
80301   void * jresult ;
80302   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80303   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80304
80305   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80306   {
80307     try {
80308       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80309     } catch (std::out_of_range& e) {
80310       {
80311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80312       };
80313     } catch (std::exception& e) {
80314       {
80315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80316       };
80317     } catch (Dali::DaliException e) {
80318       {
80319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80320       };
80321     } catch (...) {
80322       {
80323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80324       };
80325     }
80326   }
80327
80328   jresult = (void *)result;
80329   return jresult;
80330 }
80331
80332
80333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80334   void * jresult ;
80335   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80336   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80337
80338   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80339   {
80340     try {
80341       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80342     } catch (std::out_of_range& e) {
80343       {
80344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80345       };
80346     } catch (std::exception& e) {
80347       {
80348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80349       };
80350     } catch (Dali::DaliException e) {
80351       {
80352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80353       };
80354     } catch (...) {
80355       {
80356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80357       };
80358     }
80359   }
80360
80361   jresult = (void *)result;
80362   return jresult;
80363 }
80364
80365
80366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80367   void * jresult ;
80368   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80369   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80370
80371   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80372   {
80373     try {
80374       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80375     } catch (std::out_of_range& e) {
80376       {
80377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80378       };
80379     } catch (std::exception& e) {
80380       {
80381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80382       };
80383     } catch (Dali::DaliException e) {
80384       {
80385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80386       };
80387     } catch (...) {
80388       {
80389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80390       };
80391     }
80392   }
80393
80394   jresult = (void *)result;
80395   return jresult;
80396 }
80397
80398
80399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80400   void * jresult ;
80401   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80402   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80403
80404   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80405   {
80406     try {
80407       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80408     } catch (std::out_of_range& e) {
80409       {
80410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80411       };
80412     } catch (std::exception& e) {
80413       {
80414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80415       };
80416     } catch (Dali::DaliException e) {
80417       {
80418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80419       };
80420     } catch (...) {
80421       {
80422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80423       };
80424     }
80425   }
80426
80427   jresult = (void *)result;
80428   return jresult;
80429 }
80430
80431
80432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80433   void * jresult ;
80434   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80435   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80436
80437   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80438   {
80439     try {
80440       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80441     } catch (std::out_of_range& e) {
80442       {
80443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80444       };
80445     } catch (std::exception& e) {
80446       {
80447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80448       };
80449     } catch (Dali::DaliException e) {
80450       {
80451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80452       };
80453     } catch (...) {
80454       {
80455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80456       };
80457     }
80458   }
80459
80460   jresult = (void *)result;
80461   return jresult;
80462 }
80463
80464
80465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80466   void * jresult ;
80467   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80468   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80469
80470   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80471   {
80472     try {
80473       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
80474     } catch (std::out_of_range& e) {
80475       {
80476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80477       };
80478     } catch (std::exception& e) {
80479       {
80480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80481       };
80482     } catch (Dali::DaliException e) {
80483       {
80484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80485       };
80486     } catch (...) {
80487       {
80488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80489       };
80490     }
80491   }
80492
80493   jresult = (void *)result;
80494   return jresult;
80495 }
80496
80497
80498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
80499   void * jresult ;
80500   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80501   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80502
80503   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80504   {
80505     try {
80506       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
80507     } catch (std::out_of_range& e) {
80508       {
80509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80510       };
80511     } catch (std::exception& e) {
80512       {
80513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80514       };
80515     } catch (Dali::DaliException e) {
80516       {
80517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80518       };
80519     } catch (...) {
80520       {
80521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80522       };
80523     }
80524   }
80525
80526   jresult = (void *)result;
80527   return jresult;
80528 }
80529
80530
80531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80532   void * jresult ;
80533   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80534   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80535
80536   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80537   {
80538     try {
80539       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80540     } catch (std::out_of_range& e) {
80541       {
80542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80543       };
80544     } catch (std::exception& e) {
80545       {
80546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80547       };
80548     } catch (Dali::DaliException e) {
80549       {
80550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80551       };
80552     } catch (...) {
80553       {
80554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80555       };
80556     }
80557   }
80558
80559   jresult = (void *)result;
80560   return jresult;
80561 }
80562
80563
80564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80565   void * jresult ;
80566   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80567   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80568
80569   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80570   {
80571     try {
80572       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80573     } catch (std::out_of_range& e) {
80574       {
80575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80576       };
80577     } catch (std::exception& e) {
80578       {
80579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80580       };
80581     } catch (Dali::DaliException e) {
80582       {
80583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80584       };
80585     } catch (...) {
80586       {
80587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80588       };
80589     }
80590   }
80591
80592   jresult = (void *)result;
80593   return jresult;
80594 }
80595
80596
80597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80598   void * jresult ;
80599   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80600   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80601
80602   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80603   {
80604     try {
80605       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80606     } catch (std::out_of_range& e) {
80607       {
80608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80609       };
80610     } catch (std::exception& e) {
80611       {
80612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80613       };
80614     } catch (Dali::DaliException e) {
80615       {
80616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80617       };
80618     } catch (...) {
80619       {
80620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80621       };
80622     }
80623   }
80624
80625   jresult = (void *)result;
80626   return jresult;
80627 }
80628
80629
80630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80631   void * jresult ;
80632   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80633   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80634
80635   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80636   {
80637     try {
80638       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80639     } catch (std::out_of_range& e) {
80640       {
80641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80642       };
80643     } catch (std::exception& e) {
80644       {
80645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80646       };
80647     } catch (Dali::DaliException e) {
80648       {
80649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80650       };
80651     } catch (...) {
80652       {
80653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80654       };
80655     }
80656   }
80657
80658   jresult = (void *)result;
80659   return jresult;
80660 }
80661
80662
80663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80664   void * jresult ;
80665   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80666   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80667
80668   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80669   {
80670     try {
80671       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80672     } catch (std::out_of_range& e) {
80673       {
80674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80675       };
80676     } catch (std::exception& e) {
80677       {
80678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80679       };
80680     } catch (Dali::DaliException e) {
80681       {
80682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80683       };
80684     } catch (...) {
80685       {
80686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80687       };
80688     }
80689   }
80690
80691   jresult = (void *)result;
80692   return jresult;
80693 }
80694
80695
80696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
80697   void * jresult ;
80698   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80699   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80700
80701   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80702   {
80703     try {
80704       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
80705     } catch (std::out_of_range& e) {
80706       {
80707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80708       };
80709     } catch (std::exception& e) {
80710       {
80711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80712       };
80713     } catch (Dali::DaliException e) {
80714       {
80715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80716       };
80717     } catch (...) {
80718       {
80719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80720       };
80721     }
80722   }
80723
80724   jresult = (void *)result;
80725   return jresult;
80726 }
80727
80728
80729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
80730   void * jresult ;
80731   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80732   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80733
80734   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80735   {
80736     try {
80737       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
80738     } catch (std::out_of_range& e) {
80739       {
80740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80741       };
80742     } catch (std::exception& e) {
80743       {
80744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80745       };
80746     } catch (Dali::DaliException e) {
80747       {
80748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80749       };
80750     } catch (...) {
80751       {
80752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80753       };
80754     }
80755   }
80756
80757   jresult = (void *)result;
80758   return jresult;
80759 }
80760
80761
80762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
80763   void * jresult ;
80764   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80765   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
80766
80767   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80768   {
80769     try {
80770       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
80771     } catch (std::out_of_range& e) {
80772       {
80773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80774       };
80775     } catch (std::exception& e) {
80776       {
80777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80778       };
80779     } catch (Dali::DaliException e) {
80780       {
80781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80782       };
80783     } catch (...) {
80784       {
80785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80786       };
80787     }
80788   }
80789
80790   jresult = (void *)result;
80791   return jresult;
80792 }
80793
80794
80795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
80796   void * jresult ;
80797   Dali::Toolkit::StyleManager *result = 0 ;
80798
80799   {
80800     try {
80801       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
80802     } catch (std::out_of_range& e) {
80803       {
80804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80805       };
80806     } catch (std::exception& e) {
80807       {
80808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80809       };
80810     } catch (Dali::DaliException e) {
80811       {
80812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80813       };
80814     } catch (...) {
80815       {
80816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80817       };
80818     }
80819   }
80820
80821   jresult = (void *)result;
80822   return jresult;
80823 }
80824
80825
80826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
80827   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80828
80829   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80830   {
80831     try {
80832       delete arg1;
80833     } catch (std::out_of_range& e) {
80834       {
80835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80836       };
80837     } catch (std::exception& e) {
80838       {
80839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80840       };
80841     } catch (Dali::DaliException e) {
80842       {
80843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80844       };
80845     } catch (...) {
80846       {
80847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80848       };
80849     }
80850   }
80851
80852 }
80853
80854
80855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
80856   void * jresult ;
80857   Dali::Toolkit::StyleManager result;
80858
80859   {
80860     try {
80861       result = Dali::Toolkit::StyleManager::Get();
80862     } catch (std::out_of_range& e) {
80863       {
80864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80865       };
80866     } catch (std::exception& e) {
80867       {
80868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80869       };
80870     } catch (Dali::DaliException e) {
80871       {
80872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80873       };
80874     } catch (...) {
80875       {
80876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80877       };
80878     }
80879   }
80880
80881   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
80882   return jresult;
80883 }
80884
80885
80886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
80887   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80888   std::string *arg2 = 0 ;
80889
80890   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80891   if (!jarg2) {
80892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80893     return ;
80894   }
80895   std::string arg2_str(jarg2);
80896   arg2 = &arg2_str;
80897   {
80898     try {
80899       (arg1)->ApplyTheme((std::string const &)*arg2);
80900     } catch (std::out_of_range& e) {
80901       {
80902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80903       };
80904     } catch (std::exception& e) {
80905       {
80906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80907       };
80908     } catch (Dali::DaliException e) {
80909       {
80910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80911       };
80912     } catch (...) {
80913       {
80914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80915       };
80916     }
80917   }
80918
80919
80920   //argout typemap for const std::string&
80921
80922 }
80923
80924
80925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
80926   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80927
80928   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80929   {
80930     try {
80931       (arg1)->ApplyDefaultTheme();
80932     } catch (std::out_of_range& e) {
80933       {
80934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80935       };
80936     } catch (std::exception& e) {
80937       {
80938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80939       };
80940     } catch (Dali::DaliException e) {
80941       {
80942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80943       };
80944     } catch (...) {
80945       {
80946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80947       };
80948     }
80949   }
80950
80951 }
80952
80953
80954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80955   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80956   std::string *arg2 = 0 ;
80957   Dali::Property::Value *arg3 = 0 ;
80958
80959   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80960   if (!jarg2) {
80961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80962     return ;
80963   }
80964   std::string arg2_str(jarg2);
80965   arg2 = &arg2_str;
80966   arg3 = (Dali::Property::Value *)jarg3;
80967   if (!arg3) {
80968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
80969     return ;
80970   }
80971   {
80972     try {
80973       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
80974     } catch (std::out_of_range& e) {
80975       {
80976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80977       };
80978     } catch (std::exception& e) {
80979       {
80980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80981       };
80982     } catch (Dali::DaliException e) {
80983       {
80984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80985       };
80986     } catch (...) {
80987       {
80988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80989       };
80990     }
80991   }
80992
80993
80994   //argout typemap for const std::string&
80995
80996 }
80997
80998
80999 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81000   unsigned int jresult ;
81001   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81002   std::string *arg2 = 0 ;
81003   Dali::Property::Value *arg3 = 0 ;
81004   bool result;
81005
81006   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81007   if (!jarg2) {
81008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81009     return 0;
81010   }
81011   std::string arg2_str(jarg2);
81012   arg2 = &arg2_str;
81013   arg3 = (Dali::Property::Value *)jarg3;
81014   if (!arg3) {
81015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81016     return 0;
81017   }
81018   {
81019     try {
81020       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81021     } catch (std::out_of_range& e) {
81022       {
81023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81024       };
81025     } catch (std::exception& e) {
81026       {
81027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81028       };
81029     } catch (Dali::DaliException e) {
81030       {
81031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81032       };
81033     } catch (...) {
81034       {
81035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81036       };
81037     }
81038   }
81039
81040   jresult = result;
81041
81042   //argout typemap for const std::string&
81043
81044   return jresult;
81045 }
81046
81047
81048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81049   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81050   Dali::Toolkit::Control arg2 ;
81051   std::string *arg3 = 0 ;
81052   std::string *arg4 = 0 ;
81053   Dali::Toolkit::Control *argp2 ;
81054
81055   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81056   argp2 = (Dali::Toolkit::Control *)jarg2;
81057   if (!argp2) {
81058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81059     return ;
81060   }
81061   arg2 = *argp2;
81062   if (!jarg3) {
81063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81064     return ;
81065   }
81066   std::string arg3_str(jarg3);
81067   arg3 = &arg3_str;
81068   if (!jarg4) {
81069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81070     return ;
81071   }
81072   std::string arg4_str(jarg4);
81073   arg4 = &arg4_str;
81074   {
81075     try {
81076       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81077     } catch (std::out_of_range& e) {
81078       {
81079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81080       };
81081     } catch (std::exception& e) {
81082       {
81083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81084       };
81085     } catch (Dali::DaliException e) {
81086       {
81087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81088       };
81089     } catch (...) {
81090       {
81091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81092       };
81093     }
81094   }
81095
81096
81097   //argout typemap for const std::string&
81098
81099
81100   //argout typemap for const std::string&
81101
81102 }
81103
81104
81105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81106   void * jresult ;
81107   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81108   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81109
81110   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81111   {
81112     try {
81113       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81114     } catch (std::out_of_range& e) {
81115       {
81116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81117       };
81118     } catch (std::exception& e) {
81119       {
81120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81121       };
81122     } catch (Dali::DaliException e) {
81123       {
81124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81125       };
81126     } catch (...) {
81127       {
81128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81129       };
81130     }
81131   }
81132
81133   jresult = (void *)result;
81134   return jresult;
81135 }
81136
81137
81138 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81139   int jresult ;
81140   int result;
81141
81142   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81143   jresult = (int)result;
81144   return jresult;
81145 }
81146
81147
81148 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81149   int jresult ;
81150   int result;
81151
81152   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81153   jresult = (int)result;
81154   return jresult;
81155 }
81156
81157
81158 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81159   int jresult ;
81160   int result;
81161
81162   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81163   jresult = (int)result;
81164   return jresult;
81165 }
81166
81167
81168 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81169   int jresult ;
81170   int result;
81171
81172   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81173   jresult = (int)result;
81174   return jresult;
81175 }
81176
81177
81178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81179   int jresult ;
81180   int result;
81181
81182   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81183   jresult = (int)result;
81184   return jresult;
81185 }
81186
81187
81188 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81189   int jresult ;
81190   int result;
81191
81192   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81193   jresult = (int)result;
81194   return jresult;
81195 }
81196
81197
81198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81199   int jresult ;
81200   int result;
81201
81202   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81203   jresult = (int)result;
81204   return jresult;
81205 }
81206
81207
81208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81209   int jresult ;
81210   int result;
81211
81212   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81213   jresult = (int)result;
81214   return jresult;
81215 }
81216
81217
81218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81219   int jresult ;
81220   int result;
81221
81222   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81223   jresult = (int)result;
81224   return jresult;
81225 }
81226
81227
81228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81229   int jresult ;
81230   int result;
81231
81232   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81233   jresult = (int)result;
81234   return jresult;
81235 }
81236
81237
81238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81239   int jresult ;
81240   int result;
81241
81242   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81243   jresult = (int)result;
81244   return jresult;
81245 }
81246
81247
81248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81249   int jresult ;
81250   int result;
81251
81252   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81253   jresult = (int)result;
81254   return jresult;
81255 }
81256
81257
81258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81259   int jresult ;
81260   int result;
81261
81262   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81263   jresult = (int)result;
81264   return jresult;
81265 }
81266
81267
81268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81269   int jresult ;
81270   int result;
81271
81272   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81273   jresult = (int)result;
81274   return jresult;
81275 }
81276
81277
81278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81279   int jresult ;
81280   int result;
81281
81282   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81283   jresult = (int)result;
81284   return jresult;
81285 }
81286
81287
81288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81289   void * jresult ;
81290   Dali::Toolkit::Slider::Property *result = 0 ;
81291
81292   {
81293     try {
81294       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81295     } catch (std::out_of_range& e) {
81296       {
81297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81298       };
81299     } catch (std::exception& e) {
81300       {
81301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81302       };
81303     } catch (Dali::DaliException e) {
81304       {
81305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81306       };
81307     } catch (...) {
81308       {
81309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81310       };
81311     }
81312   }
81313
81314   jresult = (void *)result;
81315   return jresult;
81316 }
81317
81318
81319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81320   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81321
81322   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81323   {
81324     try {
81325       delete arg1;
81326     } catch (std::out_of_range& e) {
81327       {
81328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81329       };
81330     } catch (std::exception& e) {
81331       {
81332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81333       };
81334     } catch (Dali::DaliException e) {
81335       {
81336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81337       };
81338     } catch (...) {
81339       {
81340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81341       };
81342     }
81343   }
81344
81345 }
81346
81347
81348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81349   void * jresult ;
81350   Dali::Toolkit::Slider result;
81351
81352   {
81353     try {
81354       result = Dali::Toolkit::Slider::New();
81355     } catch (std::out_of_range& e) {
81356       {
81357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81358       };
81359     } catch (std::exception& e) {
81360       {
81361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81362       };
81363     } catch (Dali::DaliException e) {
81364       {
81365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81366       };
81367     } catch (...) {
81368       {
81369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81370       };
81371     }
81372   }
81373
81374   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81375   return jresult;
81376 }
81377
81378
81379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81380   void * jresult ;
81381   Dali::Toolkit::Slider *result = 0 ;
81382
81383   {
81384     try {
81385       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81386     } catch (std::out_of_range& e) {
81387       {
81388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81389       };
81390     } catch (std::exception& e) {
81391       {
81392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81393       };
81394     } catch (Dali::DaliException e) {
81395       {
81396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81397       };
81398     } catch (...) {
81399       {
81400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81401       };
81402     }
81403   }
81404
81405   jresult = (void *)result;
81406   return jresult;
81407 }
81408
81409
81410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
81411   void * jresult ;
81412   Dali::Toolkit::Slider *arg1 = 0 ;
81413   Dali::Toolkit::Slider *result = 0 ;
81414
81415   arg1 = (Dali::Toolkit::Slider *)jarg1;
81416   if (!arg1) {
81417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81418     return 0;
81419   }
81420   {
81421     try {
81422       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81423     } catch (std::out_of_range& e) {
81424       {
81425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81426       };
81427     } catch (std::exception& e) {
81428       {
81429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81430       };
81431     } catch (Dali::DaliException e) {
81432       {
81433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81434       };
81435     } catch (...) {
81436       {
81437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81438       };
81439     }
81440   }
81441
81442   jresult = (void *)result;
81443   return jresult;
81444 }
81445
81446
81447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
81448   void * jresult ;
81449   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81450   Dali::Toolkit::Slider *arg2 = 0 ;
81451   Dali::Toolkit::Slider *result = 0 ;
81452
81453   arg1 = (Dali::Toolkit::Slider *)jarg1;
81454   arg2 = (Dali::Toolkit::Slider *)jarg2;
81455   if (!arg2) {
81456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81457     return 0;
81458   }
81459   {
81460     try {
81461       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81462     } catch (std::out_of_range& e) {
81463       {
81464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81465       };
81466     } catch (std::exception& e) {
81467       {
81468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81469       };
81470     } catch (Dali::DaliException e) {
81471       {
81472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81473       };
81474     } catch (...) {
81475       {
81476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81477       };
81478     }
81479   }
81480
81481   jresult = (void *)result;
81482   return jresult;
81483 }
81484
81485
81486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
81487   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81488
81489   arg1 = (Dali::Toolkit::Slider *)jarg1;
81490   {
81491     try {
81492       delete arg1;
81493     } catch (std::out_of_range& e) {
81494       {
81495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81496       };
81497     } catch (std::exception& e) {
81498       {
81499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81500       };
81501     } catch (Dali::DaliException e) {
81502       {
81503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81504       };
81505     } catch (...) {
81506       {
81507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81508       };
81509     }
81510   }
81511
81512 }
81513
81514
81515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
81516   void * jresult ;
81517   Dali::BaseHandle arg1 ;
81518   Dali::BaseHandle *argp1 ;
81519   Dali::Toolkit::Slider result;
81520
81521   argp1 = (Dali::BaseHandle *)jarg1;
81522   if (!argp1) {
81523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81524     return 0;
81525   }
81526   arg1 = *argp1;
81527   {
81528     try {
81529       result = Dali::Toolkit::Slider::DownCast(arg1);
81530     } catch (std::out_of_range& e) {
81531       {
81532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81533       };
81534     } catch (std::exception& e) {
81535       {
81536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81537       };
81538     } catch (Dali::DaliException e) {
81539       {
81540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81541       };
81542     } catch (...) {
81543       {
81544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81545       };
81546     }
81547   }
81548
81549   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81550   return jresult;
81551 }
81552
81553
81554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
81555   void * jresult ;
81556   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81557   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81558
81559   arg1 = (Dali::Toolkit::Slider *)jarg1;
81560   {
81561     try {
81562       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
81563     } catch (std::out_of_range& e) {
81564       {
81565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81566       };
81567     } catch (std::exception& e) {
81568       {
81569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81570       };
81571     } catch (Dali::DaliException e) {
81572       {
81573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81574       };
81575     } catch (...) {
81576       {
81577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81578       };
81579     }
81580   }
81581
81582   jresult = (void *)result;
81583   return jresult;
81584 }
81585
81586
81587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
81588   void * jresult ;
81589   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81590   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81591
81592   arg1 = (Dali::Toolkit::Slider *)jarg1;
81593   {
81594     try {
81595       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
81596     } catch (std::out_of_range& e) {
81597       {
81598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81599       };
81600     } catch (std::exception& e) {
81601       {
81602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81603       };
81604     } catch (Dali::DaliException e) {
81605       {
81606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81607       };
81608     } catch (...) {
81609       {
81610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81611       };
81612     }
81613   }
81614
81615   jresult = (void *)result;
81616   return jresult;
81617 }
81618
81619
81620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
81621   void * jresult ;
81622   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81623   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
81624
81625   arg1 = (Dali::Toolkit::Slider *)jarg1;
81626   {
81627     try {
81628       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
81629     } catch (std::out_of_range& e) {
81630       {
81631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81632       };
81633     } catch (std::exception& e) {
81634       {
81635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81636       };
81637     } catch (Dali::DaliException e) {
81638       {
81639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81640       };
81641     } catch (...) {
81642       {
81643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81644       };
81645     }
81646   }
81647
81648   jresult = (void *)result;
81649   return jresult;
81650 }
81651
81652
81653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
81654   int jresult ;
81655   int result;
81656
81657   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81658   jresult = (int)result;
81659   return jresult;
81660 }
81661
81662
81663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
81664   int jresult ;
81665   int result;
81666
81667   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81668   jresult = (int)result;
81669   return jresult;
81670 }
81671
81672
81673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
81674   int jresult ;
81675   int result;
81676
81677   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81678   jresult = (int)result;
81679   return jresult;
81680 }
81681
81682
81683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
81684   int jresult ;
81685   int result;
81686
81687   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81688   jresult = (int)result;
81689   return jresult;
81690 }
81691
81692
81693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
81694   int result;
81695
81696   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
81697
81698   return result;
81699 }
81700
81701
81702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
81703   void * jresult ;
81704   Dali::Toolkit::VideoView::Property *result = 0 ;
81705
81706   {
81707     try {
81708       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
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 = (void *)result;
81729   return jresult;
81730 }
81731
81732
81733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
81734   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81735
81736   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
81737   {
81738     try {
81739       delete arg1;
81740     } catch (std::out_of_range& e) {
81741       {
81742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81743       };
81744     } catch (std::exception& e) {
81745       {
81746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81747       };
81748     } catch (Dali::DaliException e) {
81749       {
81750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81751       };
81752     } catch (...) {
81753       {
81754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81755       };
81756     }
81757   }
81758
81759 }
81760
81761
81762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
81763   void * jresult ;
81764   Dali::Toolkit::VideoView result;
81765
81766   {
81767     try {
81768       result = Dali::Toolkit::VideoView::New();
81769     } catch (std::out_of_range& e) {
81770       {
81771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81772       };
81773     } catch (std::exception& e) {
81774       {
81775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81776       };
81777     } catch (Dali::DaliException e) {
81778       {
81779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81780       };
81781     } catch (...) {
81782       {
81783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81784       };
81785     }
81786   }
81787
81788   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81789   return jresult;
81790 }
81791
81792
81793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
81794   void * jresult ;
81795   std::string *arg1 = 0 ;
81796   Dali::Toolkit::VideoView result;
81797
81798   if (!jarg1) {
81799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81800     return 0;
81801   }
81802   std::string arg1_str(jarg1);
81803   arg1 = &arg1_str;
81804   {
81805     try {
81806       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81807     } catch (std::out_of_range& e) {
81808       {
81809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81810       };
81811     } catch (std::exception& e) {
81812       {
81813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81814       };
81815     } catch (Dali::DaliException e) {
81816       {
81817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81818       };
81819     } catch (...) {
81820       {
81821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81822       };
81823     }
81824   }
81825
81826   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81827
81828   //argout typemap for const std::string&
81829
81830   return jresult;
81831 }
81832
81833
81834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
81835   void * jresult ;
81836   Dali::Toolkit::VideoView result;
81837   {
81838     try {
81839       result = Dali::Toolkit::VideoView::New(swCodec);
81840     } catch (std::out_of_range& e) {
81841       {
81842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81843       };
81844     } catch (std::exception& e) {
81845       {
81846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81847       };
81848     } catch (Dali::DaliException e) {
81849       {
81850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81851       };
81852     } catch (...) {
81853       {
81854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81855       };
81856     }
81857   }
81858
81859   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81860
81861   //argout typemap for const std::string&
81862
81863   return jresult;
81864 }
81865
81866
81867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
81868   void * jresult ;
81869   std::string *arg1 = 0 ;
81870   Dali::Toolkit::VideoView result;
81871
81872   if (!jarg1) {
81873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81874     return 0;
81875   }
81876   std::string arg1_str(jarg1);
81877   arg1 = &arg1_str;
81878   {
81879     try {
81880       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
81881     } catch (std::out_of_range& e) {
81882       {
81883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81884       };
81885     } catch (std::exception& e) {
81886       {
81887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81888       };
81889     } catch (Dali::DaliException e) {
81890       {
81891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81892       };
81893     } catch (...) {
81894       {
81895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81896       };
81897     }
81898   }
81899
81900   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81901
81902   //argout typemap for const std::string&
81903
81904   return jresult;
81905 }
81906
81907
81908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
81909   void * jresult ;
81910   Dali::Toolkit::VideoView *result = 0 ;
81911
81912   {
81913     try {
81914       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
81915     } catch (std::out_of_range& e) {
81916       {
81917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81918       };
81919     } catch (std::exception& e) {
81920       {
81921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81922       };
81923     } catch (Dali::DaliException e) {
81924       {
81925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81926       };
81927     } catch (...) {
81928       {
81929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81930       };
81931     }
81932   }
81933
81934   jresult = (void *)result;
81935   return jresult;
81936 }
81937
81938
81939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
81940   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81941
81942   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81943   {
81944     try {
81945       delete arg1;
81946     } catch (std::out_of_range& e) {
81947       {
81948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81949       };
81950     } catch (std::exception& e) {
81951       {
81952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81953       };
81954     } catch (Dali::DaliException e) {
81955       {
81956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81957       };
81958     } catch (...) {
81959       {
81960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81961       };
81962     }
81963   }
81964
81965 }
81966
81967
81968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
81969   void * jresult ;
81970   Dali::Toolkit::VideoView *arg1 = 0 ;
81971   Dali::Toolkit::VideoView *result = 0 ;
81972
81973   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81974   if (!arg1) {
81975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
81976     return 0;
81977   }
81978   {
81979     try {
81980       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
81981     } catch (std::out_of_range& e) {
81982       {
81983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81984       };
81985     } catch (std::exception& e) {
81986       {
81987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81988       };
81989     } catch (Dali::DaliException e) {
81990       {
81991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81992       };
81993     } catch (...) {
81994       {
81995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81996       };
81997     }
81998   }
81999
82000   jresult = (void *)result;
82001   return jresult;
82002 }
82003
82004
82005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82006   void * jresult ;
82007   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82008   Dali::Toolkit::VideoView *arg2 = 0 ;
82009   Dali::Toolkit::VideoView *result = 0 ;
82010
82011   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82012   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82013   if (!arg2) {
82014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82015     return 0;
82016   }
82017   {
82018     try {
82019       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82020     } catch (std::out_of_range& e) {
82021       {
82022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82023       };
82024     } catch (std::exception& e) {
82025       {
82026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82027       };
82028     } catch (Dali::DaliException e) {
82029       {
82030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82031       };
82032     } catch (...) {
82033       {
82034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82035       };
82036     }
82037   }
82038
82039   jresult = (void *)result;
82040   return jresult;
82041 }
82042
82043
82044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82045   void * jresult ;
82046   Dali::BaseHandle arg1 ;
82047   Dali::BaseHandle *argp1 ;
82048   Dali::Toolkit::VideoView result;
82049
82050   argp1 = (Dali::BaseHandle *)jarg1;
82051   if (!argp1) {
82052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82053     return 0;
82054   }
82055   arg1 = *argp1;
82056   {
82057     try {
82058       result = Dali::Toolkit::VideoView::DownCast(arg1);
82059     } catch (std::out_of_range& e) {
82060       {
82061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82062       };
82063     } catch (std::exception& e) {
82064       {
82065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82066       };
82067     } catch (Dali::DaliException e) {
82068       {
82069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82070       };
82071     } catch (...) {
82072       {
82073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82074       };
82075     }
82076   }
82077
82078   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82079   return jresult;
82080 }
82081
82082
82083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82084   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82085
82086   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82087   {
82088     try {
82089       (arg1)->Play();
82090     } catch (std::out_of_range& e) {
82091       {
82092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82093       };
82094     } catch (std::exception& e) {
82095       {
82096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82097       };
82098     } catch (Dali::DaliException e) {
82099       {
82100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82101       };
82102     } catch (...) {
82103       {
82104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82105       };
82106     }
82107   }
82108
82109 }
82110
82111
82112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82113   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82114
82115   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82116   {
82117     try {
82118       (arg1)->Pause();
82119     } catch (std::out_of_range& e) {
82120       {
82121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82122       };
82123     } catch (std::exception& e) {
82124       {
82125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82126       };
82127     } catch (Dali::DaliException e) {
82128       {
82129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82130       };
82131     } catch (...) {
82132       {
82133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82134       };
82135     }
82136   }
82137
82138 }
82139
82140
82141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82142   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82143
82144   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82145   {
82146     try {
82147       (arg1)->Stop();
82148     } catch (std::out_of_range& e) {
82149       {
82150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82151       };
82152     } catch (std::exception& e) {
82153       {
82154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82155       };
82156     } catch (Dali::DaliException e) {
82157       {
82158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82159       };
82160     } catch (...) {
82161       {
82162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82163       };
82164     }
82165   }
82166
82167 }
82168
82169
82170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82171   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82172   int arg2 ;
82173
82174   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82175   arg2 = (int)jarg2;
82176   {
82177     try {
82178       (arg1)->Forward(arg2);
82179     } catch (std::out_of_range& e) {
82180       {
82181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82182       };
82183     } catch (std::exception& e) {
82184       {
82185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82186       };
82187     } catch (Dali::DaliException e) {
82188       {
82189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82190       };
82191     } catch (...) {
82192       {
82193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82194       };
82195     }
82196   }
82197
82198 }
82199
82200
82201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82202   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82203   int arg2 ;
82204
82205   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82206   arg2 = (int)jarg2;
82207   {
82208     try {
82209       (arg1)->Backward(arg2);
82210     } catch (std::out_of_range& e) {
82211       {
82212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82213       };
82214     } catch (std::exception& e) {
82215       {
82216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82217       };
82218     } catch (Dali::DaliException e) {
82219       {
82220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82221       };
82222     } catch (...) {
82223       {
82224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82225       };
82226     }
82227   }
82228
82229 }
82230
82231
82232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82233   void * jresult ;
82234   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82235   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82236
82237   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82238   {
82239     try {
82240       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82241     } catch (std::out_of_range& e) {
82242       {
82243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82244       };
82245     } catch (std::exception& e) {
82246       {
82247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82248       };
82249     } catch (Dali::DaliException e) {
82250       {
82251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82252       };
82253     } catch (...) {
82254       {
82255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82256       };
82257     }
82258   }
82259
82260   jresult = (void *)result;
82261   return jresult;
82262 }
82263
82264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
82265 {
82266   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
82267   if( arg1 == nullptr )
82268   {
82269     DALI_LOG_ERROR("VideoView is nullptr!");
82270     return nullptr;
82271   }
82272   void * ret = nullptr;
82273   {
82274     try{
82275
82276       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
82277       ret = Dali::AnyCast< void * >( result );
82278
82279     } catch (std::out_of_range& e) {
82280       {
82281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82282       };
82283     } catch (std::exception& e) {
82284       {
82285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82286       };
82287     } catch (Dali::DaliException e) {
82288       {
82289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82290       };
82291     } catch (...) {
82292       {
82293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82294       };
82295     }
82296   }
82297   return ret;
82298 }
82299
82300
82301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82302   int jresult ;
82303   int result;
82304
82305   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82306   jresult = (int)result;
82307   return jresult;
82308 }
82309
82310
82311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82312   int jresult ;
82313   int result;
82314
82315   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82316   jresult = (int)result;
82317   return jresult;
82318 }
82319
82320
82321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82322   int jresult ;
82323   int result;
82324
82325   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82326   jresult = (int)result;
82327   return jresult;
82328 }
82329
82330
82331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82332   int jresult ;
82333   int result;
82334
82335   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82336   jresult = (int)result;
82337   return jresult;
82338 }
82339
82340
82341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82342   int jresult ;
82343   int result;
82344
82345   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82346   jresult = (int)result;
82347   return jresult;
82348 }
82349
82350
82351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82352   int jresult ;
82353   int result;
82354
82355   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82356   jresult = (int)result;
82357   return jresult;
82358 }
82359
82360
82361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82362   int jresult ;
82363   int result;
82364
82365   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82366   jresult = (int)result;
82367   return jresult;
82368 }
82369
82370
82371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82372   int jresult ;
82373   int result;
82374
82375   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82376   jresult = (int)result;
82377   return jresult;
82378 }
82379
82380
82381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82382   int jresult ;
82383   int result;
82384
82385   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82386   jresult = (int)result;
82387   return jresult;
82388 }
82389
82390
82391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82392   int jresult ;
82393   int result;
82394
82395   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82396   jresult = (int)result;
82397   return jresult;
82398 }
82399
82400
82401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82402   int jresult ;
82403   int result;
82404
82405   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82406   jresult = (int)result;
82407   return jresult;
82408 }
82409
82410
82411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82412   int jresult ;
82413   int result;
82414
82415   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82416   jresult = (int)result;
82417   return jresult;
82418 }
82419
82420
82421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82422   int jresult ;
82423   int result;
82424
82425   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82426   jresult = (int)result;
82427   return jresult;
82428 }
82429
82430
82431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82432   int jresult ;
82433   int result;
82434
82435   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82436   jresult = (int)result;
82437   return jresult;
82438 }
82439
82440
82441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82442   int jresult ;
82443   int result;
82444
82445   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82446   jresult = (int)result;
82447   return jresult;
82448 }
82449
82450
82451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82452   int jresult ;
82453   int result;
82454
82455   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82456   jresult = (int)result;
82457   return jresult;
82458 }
82459
82460
82461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82462   int jresult ;
82463   int result;
82464
82465   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82466   jresult = (int)result;
82467   return jresult;
82468 }
82469
82470
82471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82472   int jresult ;
82473   int result;
82474
82475   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82476   jresult = (int)result;
82477   return jresult;
82478 }
82479
82480
82481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82482   int jresult ;
82483   int result;
82484
82485   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82486   jresult = (int)result;
82487   return jresult;
82488 }
82489
82490
82491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82492   int jresult ;
82493   int result;
82494
82495   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82496   jresult = (int)result;
82497   return jresult;
82498 }
82499
82500
82501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82502   int jresult ;
82503   int result;
82504
82505   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82506   jresult = (int)result;
82507   return jresult;
82508 }
82509
82510
82511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82512   void * jresult ;
82513   Dali::Toolkit::Popup::Property *result = 0 ;
82514
82515   {
82516     try {
82517       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82518     } catch (std::out_of_range& e) {
82519       {
82520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82521       };
82522     } catch (std::exception& e) {
82523       {
82524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82525       };
82526     } catch (Dali::DaliException e) {
82527       {
82528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82529       };
82530     } catch (...) {
82531       {
82532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82533       };
82534     }
82535   }
82536
82537   jresult = (void *)result;
82538   return jresult;
82539 }
82540
82541
82542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82543   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82544
82545   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82546   {
82547     try {
82548       delete arg1;
82549     } catch (std::out_of_range& e) {
82550       {
82551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82552       };
82553     } catch (std::exception& e) {
82554       {
82555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82556       };
82557     } catch (Dali::DaliException e) {
82558       {
82559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82560       };
82561     } catch (...) {
82562       {
82563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82564       };
82565     }
82566   }
82567
82568 }
82569
82570
82571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82572   void * jresult ;
82573   Dali::Toolkit::Popup *result = 0 ;
82574
82575   {
82576     try {
82577       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82578     } catch (std::out_of_range& e) {
82579       {
82580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82581       };
82582     } catch (std::exception& e) {
82583       {
82584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82585       };
82586     } catch (Dali::DaliException e) {
82587       {
82588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82589       };
82590     } catch (...) {
82591       {
82592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82593       };
82594     }
82595   }
82596
82597   jresult = (void *)result;
82598   return jresult;
82599 }
82600
82601
82602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82603   void * jresult ;
82604   Dali::Toolkit::Popup result;
82605
82606   {
82607     try {
82608       result = Dali::Toolkit::Popup::New();
82609     } catch (std::out_of_range& e) {
82610       {
82611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82612       };
82613     } catch (std::exception& e) {
82614       {
82615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82616       };
82617     } catch (Dali::DaliException e) {
82618       {
82619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82620       };
82621     } catch (...) {
82622       {
82623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82624       };
82625     }
82626   }
82627
82628   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82629   return jresult;
82630 }
82631
82632
82633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82634   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82635
82636   arg1 = (Dali::Toolkit::Popup *)jarg1;
82637   {
82638     try {
82639       delete arg1;
82640     } catch (std::out_of_range& e) {
82641       {
82642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82643       };
82644     } catch (std::exception& e) {
82645       {
82646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82647       };
82648     } catch (Dali::DaliException e) {
82649       {
82650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82651       };
82652     } catch (...) {
82653       {
82654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82655       };
82656     }
82657   }
82658
82659 }
82660
82661
82662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
82663   void * jresult ;
82664   Dali::Toolkit::Popup *arg1 = 0 ;
82665   Dali::Toolkit::Popup *result = 0 ;
82666
82667   arg1 = (Dali::Toolkit::Popup *)jarg1;
82668   if (!arg1) {
82669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82670     return 0;
82671   }
82672   {
82673     try {
82674       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
82675     } catch (std::out_of_range& e) {
82676       {
82677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82678       };
82679     } catch (std::exception& e) {
82680       {
82681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82682       };
82683     } catch (Dali::DaliException e) {
82684       {
82685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82686       };
82687     } catch (...) {
82688       {
82689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82690       };
82691     }
82692   }
82693
82694   jresult = (void *)result;
82695   return jresult;
82696 }
82697
82698
82699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
82700   void * jresult ;
82701   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82702   Dali::Toolkit::Popup *arg2 = 0 ;
82703   Dali::Toolkit::Popup *result = 0 ;
82704
82705   arg1 = (Dali::Toolkit::Popup *)jarg1;
82706   arg2 = (Dali::Toolkit::Popup *)jarg2;
82707   if (!arg2) {
82708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82709     return 0;
82710   }
82711   {
82712     try {
82713       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
82714     } catch (std::out_of_range& e) {
82715       {
82716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82717       };
82718     } catch (std::exception& e) {
82719       {
82720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82721       };
82722     } catch (Dali::DaliException e) {
82723       {
82724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82725       };
82726     } catch (...) {
82727       {
82728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82729       };
82730     }
82731   }
82732
82733   jresult = (void *)result;
82734   return jresult;
82735 }
82736
82737
82738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
82739   void * jresult ;
82740   Dali::BaseHandle arg1 ;
82741   Dali::BaseHandle *argp1 ;
82742   Dali::Toolkit::Popup result;
82743
82744   argp1 = (Dali::BaseHandle *)jarg1;
82745   if (!argp1) {
82746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82747     return 0;
82748   }
82749   arg1 = *argp1;
82750   {
82751     try {
82752       result = Dali::Toolkit::Popup::DownCast(arg1);
82753     } catch (std::out_of_range& e) {
82754       {
82755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82756       };
82757     } catch (std::exception& e) {
82758       {
82759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82760       };
82761     } catch (Dali::DaliException e) {
82762       {
82763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82764       };
82765     } catch (...) {
82766       {
82767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82768       };
82769     }
82770   }
82771
82772   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82773   return jresult;
82774 }
82775
82776
82777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
82778   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82779   Dali::Actor arg2 ;
82780   Dali::Actor *argp2 ;
82781
82782   arg1 = (Dali::Toolkit::Popup *)jarg1;
82783   argp2 = (Dali::Actor *)jarg2;
82784   if (!argp2) {
82785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82786     return ;
82787   }
82788   arg2 = *argp2;
82789   {
82790     try {
82791       (arg1)->SetTitle(arg2);
82792     } catch (std::out_of_range& e) {
82793       {
82794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82795       };
82796     } catch (std::exception& e) {
82797       {
82798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82799       };
82800     } catch (Dali::DaliException e) {
82801       {
82802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82803       };
82804     } catch (...) {
82805       {
82806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82807       };
82808     }
82809   }
82810
82811 }
82812
82813
82814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
82815   void * jresult ;
82816   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82817   Dali::Actor result;
82818
82819   arg1 = (Dali::Toolkit::Popup *)jarg1;
82820   {
82821     try {
82822       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
82823     } catch (std::out_of_range& e) {
82824       {
82825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82826       };
82827     } catch (std::exception& e) {
82828       {
82829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82830       };
82831     } catch (Dali::DaliException e) {
82832       {
82833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82834       };
82835     } catch (...) {
82836       {
82837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82838       };
82839     }
82840   }
82841
82842   jresult = new Dali::Actor((const Dali::Actor &)result);
82843   return jresult;
82844 }
82845
82846
82847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
82848   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82849   Dali::Actor arg2 ;
82850   Dali::Actor *argp2 ;
82851
82852   arg1 = (Dali::Toolkit::Popup *)jarg1;
82853   argp2 = (Dali::Actor *)jarg2;
82854   if (!argp2) {
82855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82856     return ;
82857   }
82858   arg2 = *argp2;
82859   {
82860     try {
82861       (arg1)->SetContent(arg2);
82862     } catch (std::out_of_range& e) {
82863       {
82864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82865       };
82866     } catch (std::exception& e) {
82867       {
82868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82869       };
82870     } catch (Dali::DaliException e) {
82871       {
82872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82873       };
82874     } catch (...) {
82875       {
82876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82877       };
82878     }
82879   }
82880
82881 }
82882
82883
82884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
82885   void * jresult ;
82886   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82887   Dali::Actor result;
82888
82889   arg1 = (Dali::Toolkit::Popup *)jarg1;
82890   {
82891     try {
82892       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
82893     } catch (std::out_of_range& e) {
82894       {
82895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82896       };
82897     } catch (std::exception& e) {
82898       {
82899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82900       };
82901     } catch (Dali::DaliException e) {
82902       {
82903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82904       };
82905     } catch (...) {
82906       {
82907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82908       };
82909     }
82910   }
82911
82912   jresult = new Dali::Actor((const Dali::Actor &)result);
82913   return jresult;
82914 }
82915
82916
82917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
82918   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82919   Dali::Actor arg2 ;
82920   Dali::Actor *argp2 ;
82921
82922   arg1 = (Dali::Toolkit::Popup *)jarg1;
82923   argp2 = (Dali::Actor *)jarg2;
82924   if (!argp2) {
82925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82926     return ;
82927   }
82928   arg2 = *argp2;
82929   {
82930     try {
82931       (arg1)->SetFooter(arg2);
82932     } catch (std::out_of_range& e) {
82933       {
82934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82935       };
82936     } catch (std::exception& e) {
82937       {
82938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82939       };
82940     } catch (Dali::DaliException e) {
82941       {
82942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82943       };
82944     } catch (...) {
82945       {
82946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82947       };
82948     }
82949   }
82950
82951 }
82952
82953
82954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
82955   void * jresult ;
82956   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82957   Dali::Actor result;
82958
82959   arg1 = (Dali::Toolkit::Popup *)jarg1;
82960   {
82961     try {
82962       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
82963     } catch (std::out_of_range& e) {
82964       {
82965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82966       };
82967     } catch (std::exception& e) {
82968       {
82969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82970       };
82971     } catch (Dali::DaliException e) {
82972       {
82973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82974       };
82975     } catch (...) {
82976       {
82977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82978       };
82979     }
82980   }
82981
82982   jresult = new Dali::Actor((const Dali::Actor &)result);
82983   return jresult;
82984 }
82985
82986
82987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
82988   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82989   Dali::Toolkit::Popup::DisplayState arg2 ;
82990
82991   arg1 = (Dali::Toolkit::Popup *)jarg1;
82992   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
82993   {
82994     try {
82995       (arg1)->SetDisplayState(arg2);
82996     } catch (std::out_of_range& e) {
82997       {
82998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82999       };
83000     } catch (std::exception& e) {
83001       {
83002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83003       };
83004     } catch (Dali::DaliException e) {
83005       {
83006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83007       };
83008     } catch (...) {
83009       {
83010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83011       };
83012     }
83013   }
83014
83015 }
83016
83017
83018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83019   int jresult ;
83020   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83021   Dali::Toolkit::Popup::DisplayState result;
83022
83023   arg1 = (Dali::Toolkit::Popup *)jarg1;
83024   {
83025     try {
83026       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83027     } catch (std::out_of_range& e) {
83028       {
83029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83030       };
83031     } catch (std::exception& e) {
83032       {
83033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83034       };
83035     } catch (Dali::DaliException e) {
83036       {
83037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83038       };
83039     } catch (...) {
83040       {
83041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83042       };
83043     }
83044   }
83045
83046   jresult = (int)result;
83047   return jresult;
83048 }
83049
83050
83051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83052   void * jresult ;
83053   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83054   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83055
83056   arg1 = (Dali::Toolkit::Popup *)jarg1;
83057   {
83058     try {
83059       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83060     } catch (std::out_of_range& e) {
83061       {
83062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83063       };
83064     } catch (std::exception& e) {
83065       {
83066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83067       };
83068     } catch (Dali::DaliException e) {
83069       {
83070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83071       };
83072     } catch (...) {
83073       {
83074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83075       };
83076     }
83077   }
83078
83079   jresult = (void *)result;
83080   return jresult;
83081 }
83082
83083
83084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83085   void * jresult ;
83086   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83087   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83088
83089   arg1 = (Dali::Toolkit::Popup *)jarg1;
83090   {
83091     try {
83092       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83093     } catch (std::out_of_range& e) {
83094       {
83095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83096       };
83097     } catch (std::exception& e) {
83098       {
83099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83100       };
83101     } catch (Dali::DaliException e) {
83102       {
83103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83104       };
83105     } catch (...) {
83106       {
83107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83108       };
83109     }
83110   }
83111
83112   jresult = (void *)result;
83113   return jresult;
83114 }
83115
83116
83117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83118   void * jresult ;
83119   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83120   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83121
83122   arg1 = (Dali::Toolkit::Popup *)jarg1;
83123   {
83124     try {
83125       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83126     } catch (std::out_of_range& e) {
83127       {
83128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83129       };
83130     } catch (std::exception& e) {
83131       {
83132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83133       };
83134     } catch (Dali::DaliException e) {
83135       {
83136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83137       };
83138     } catch (...) {
83139       {
83140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83141       };
83142     }
83143   }
83144
83145   jresult = (void *)result;
83146   return jresult;
83147 }
83148
83149
83150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83151   void * jresult ;
83152   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83153   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83154
83155   arg1 = (Dali::Toolkit::Popup *)jarg1;
83156   {
83157     try {
83158       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83159     } catch (std::out_of_range& e) {
83160       {
83161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83162       };
83163     } catch (std::exception& e) {
83164       {
83165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83166       };
83167     } catch (Dali::DaliException e) {
83168       {
83169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83170       };
83171     } catch (...) {
83172       {
83173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83174       };
83175     }
83176   }
83177
83178   jresult = (void *)result;
83179   return jresult;
83180 }
83181
83182
83183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83184   void * jresult ;
83185   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83186   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83187
83188   arg1 = (Dali::Toolkit::Popup *)jarg1;
83189   {
83190     try {
83191       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83192     } catch (std::out_of_range& e) {
83193       {
83194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83195       };
83196     } catch (std::exception& e) {
83197       {
83198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83199       };
83200     } catch (Dali::DaliException e) {
83201       {
83202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83203       };
83204     } catch (...) {
83205       {
83206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83207       };
83208     }
83209   }
83210
83211   jresult = (void *)result;
83212   return jresult;
83213 }
83214
83215
83216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83217   int jresult ;
83218   int result;
83219
83220   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83221   jresult = (int)result;
83222   return jresult;
83223 }
83224
83225
83226 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83227   int jresult ;
83228   int result;
83229
83230   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83231   jresult = (int)result;
83232   return jresult;
83233 }
83234
83235
83236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83237   int jresult ;
83238   int result;
83239
83240   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83241   jresult = (int)result;
83242   return jresult;
83243 }
83244
83245
83246 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83247   int jresult ;
83248   int result;
83249
83250   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83251   jresult = (int)result;
83252   return jresult;
83253 }
83254
83255
83256 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83257   int jresult ;
83258   int result;
83259
83260   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83261   jresult = (int)result;
83262   return jresult;
83263 }
83264
83265
83266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83267   int jresult ;
83268   int result;
83269
83270   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83271   jresult = (int)result;
83272   return jresult;
83273 }
83274
83275
83276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83277   int jresult ;
83278   int result;
83279
83280   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83281   jresult = (int)result;
83282   return jresult;
83283 }
83284
83285
83286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83287   int jresult ;
83288   int result;
83289
83290   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83291   jresult = (int)result;
83292   return jresult;
83293 }
83294
83295
83296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83297   int jresult ;
83298   int result;
83299
83300   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83301   jresult = (int)result;
83302   return jresult;
83303 }
83304
83305
83306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83307   void * jresult ;
83308   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83309
83310   {
83311     try {
83312       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83313     } catch (std::out_of_range& e) {
83314       {
83315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83316       };
83317     } catch (std::exception& e) {
83318       {
83319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83320       };
83321     } catch (Dali::DaliException e) {
83322       {
83323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83324       };
83325     } catch (...) {
83326       {
83327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83328       };
83329     }
83330   }
83331
83332   jresult = (void *)result;
83333   return jresult;
83334 }
83335
83336
83337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83338   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83339
83340   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83341   {
83342     try {
83343       delete arg1;
83344     } catch (std::out_of_range& e) {
83345       {
83346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83347       };
83348     } catch (std::exception& e) {
83349       {
83350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83351       };
83352     } catch (Dali::DaliException e) {
83353       {
83354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83355       };
83356     } catch (...) {
83357       {
83358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83359       };
83360     }
83361   }
83362
83363 }
83364
83365
83366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83367   void * jresult ;
83368   Dali::Toolkit::ProgressBar result;
83369
83370   {
83371     try {
83372       result = Dali::Toolkit::ProgressBar::New();
83373     } catch (std::out_of_range& e) {
83374       {
83375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83376       };
83377     } catch (std::exception& e) {
83378       {
83379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83380       };
83381     } catch (Dali::DaliException e) {
83382       {
83383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83384       };
83385     } catch (...) {
83386       {
83387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83388       };
83389     }
83390   }
83391
83392   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83393   return jresult;
83394 }
83395
83396
83397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83398   void * jresult ;
83399   Dali::Toolkit::ProgressBar *result = 0 ;
83400
83401   {
83402     try {
83403       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83404     } catch (std::out_of_range& e) {
83405       {
83406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83407       };
83408     } catch (std::exception& e) {
83409       {
83410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83411       };
83412     } catch (Dali::DaliException e) {
83413       {
83414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83415       };
83416     } catch (...) {
83417       {
83418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83419       };
83420     }
83421   }
83422
83423   jresult = (void *)result;
83424   return jresult;
83425 }
83426
83427
83428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83429   void * jresult ;
83430   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83431   Dali::Toolkit::ProgressBar *result = 0 ;
83432
83433   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83434   if (!arg1) {
83435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83436     return 0;
83437   }
83438   {
83439     try {
83440       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83441     } catch (std::out_of_range& e) {
83442       {
83443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83444       };
83445     } catch (std::exception& e) {
83446       {
83447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83448       };
83449     } catch (Dali::DaliException e) {
83450       {
83451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83452       };
83453     } catch (...) {
83454       {
83455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83456       };
83457     }
83458   }
83459
83460   jresult = (void *)result;
83461   return jresult;
83462 }
83463
83464
83465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83466   void * jresult ;
83467   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83468   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83469   Dali::Toolkit::ProgressBar *result = 0 ;
83470
83471   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83472   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83473   if (!arg2) {
83474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83475     return 0;
83476   }
83477   {
83478     try {
83479       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83480     } catch (std::out_of_range& e) {
83481       {
83482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83483       };
83484     } catch (std::exception& e) {
83485       {
83486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83487       };
83488     } catch (Dali::DaliException e) {
83489       {
83490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83491       };
83492     } catch (...) {
83493       {
83494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83495       };
83496     }
83497   }
83498
83499   jresult = (void *)result;
83500   return jresult;
83501 }
83502
83503
83504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83505   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83506
83507   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83508   {
83509     try {
83510       delete arg1;
83511     } catch (std::out_of_range& e) {
83512       {
83513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83514       };
83515     } catch (std::exception& e) {
83516       {
83517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83518       };
83519     } catch (Dali::DaliException e) {
83520       {
83521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83522       };
83523     } catch (...) {
83524       {
83525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83526       };
83527     }
83528   }
83529
83530 }
83531
83532
83533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83534   void * jresult ;
83535   Dali::BaseHandle arg1 ;
83536   Dali::BaseHandle *argp1 ;
83537   Dali::Toolkit::ProgressBar result;
83538
83539   argp1 = (Dali::BaseHandle *)jarg1;
83540   if (!argp1) {
83541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83542     return 0;
83543   }
83544   arg1 = *argp1;
83545   {
83546     try {
83547       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83548     } catch (std::out_of_range& e) {
83549       {
83550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83551       };
83552     } catch (std::exception& e) {
83553       {
83554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83555       };
83556     } catch (Dali::DaliException e) {
83557       {
83558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83559       };
83560     } catch (...) {
83561       {
83562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83563       };
83564     }
83565   }
83566
83567   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83568   return jresult;
83569 }
83570
83571
83572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83573   void * jresult ;
83574   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83575   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83576
83577   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83578   {
83579     try {
83580       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83581     } catch (std::out_of_range& e) {
83582       {
83583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83584       };
83585     } catch (std::exception& e) {
83586       {
83587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83588       };
83589     } catch (Dali::DaliException e) {
83590       {
83591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83592       };
83593     } catch (...) {
83594       {
83595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83596       };
83597     }
83598   }
83599
83600   jresult = (void *)result;
83601   return jresult;
83602 }
83603
83604
83605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83606   void * jresult ;
83607   Dali::Toolkit::GaussianBlurView *result = 0 ;
83608
83609   {
83610     try {
83611       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83612     } catch (std::out_of_range& e) {
83613       {
83614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83615       };
83616     } catch (std::exception& e) {
83617       {
83618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83619       };
83620     } catch (Dali::DaliException e) {
83621       {
83622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83623       };
83624     } catch (...) {
83625       {
83626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83627       };
83628     }
83629   }
83630
83631   jresult = (void *)result;
83632   return jresult;
83633 }
83634
83635
83636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83637   void * jresult ;
83638   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83639   Dali::Toolkit::GaussianBlurView *result = 0 ;
83640
83641   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83642   if (!arg1) {
83643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83644     return 0;
83645   }
83646   {
83647     try {
83648       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83649     } catch (std::out_of_range& e) {
83650       {
83651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83652       };
83653     } catch (std::exception& e) {
83654       {
83655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83656       };
83657     } catch (Dali::DaliException e) {
83658       {
83659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83660       };
83661     } catch (...) {
83662       {
83663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83664       };
83665     }
83666   }
83667
83668   jresult = (void *)result;
83669   return jresult;
83670 }
83671
83672
83673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83674   void * jresult ;
83675   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83676   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83677   Dali::Toolkit::GaussianBlurView *result = 0 ;
83678
83679   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83680   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83681   if (!arg2) {
83682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83683     return 0;
83684   }
83685   {
83686     try {
83687       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
83688     } catch (std::out_of_range& e) {
83689       {
83690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83691       };
83692     } catch (std::exception& e) {
83693       {
83694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83695       };
83696     } catch (Dali::DaliException e) {
83697       {
83698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83699       };
83700     } catch (...) {
83701       {
83702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83703       };
83704     }
83705   }
83706
83707   jresult = (void *)result;
83708   return jresult;
83709 }
83710
83711
83712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
83713   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83714
83715   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83716   {
83717     try {
83718       delete arg1;
83719     } catch (std::out_of_range& e) {
83720       {
83721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83722       };
83723     } catch (std::exception& e) {
83724       {
83725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83726       };
83727     } catch (Dali::DaliException e) {
83728       {
83729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83730       };
83731     } catch (...) {
83732       {
83733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83734       };
83735     }
83736   }
83737
83738 }
83739
83740
83741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
83742   void * jresult ;
83743   Dali::BaseHandle arg1 ;
83744   Dali::BaseHandle *argp1 ;
83745   Dali::Toolkit::GaussianBlurView result;
83746
83747   argp1 = (Dali::BaseHandle *)jarg1;
83748   if (!argp1) {
83749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83750     return 0;
83751   }
83752   arg1 = *argp1;
83753   {
83754     try {
83755       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83756     } catch (std::out_of_range& e) {
83757       {
83758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83759       };
83760     } catch (std::exception& e) {
83761       {
83762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83763       };
83764     } catch (Dali::DaliException e) {
83765       {
83766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83767       };
83768     } catch (...) {
83769       {
83770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83771       };
83772     }
83773   }
83774
83775   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83776   return jresult;
83777 }
83778
83779
83780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
83781   void * jresult ;
83782   Dali::Toolkit::GaussianBlurView result;
83783
83784   {
83785     try {
83786       result = Dali::Toolkit::GaussianBlurView::New();
83787     } catch (std::out_of_range& e) {
83788       {
83789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83790       };
83791     } catch (std::exception& e) {
83792       {
83793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83794       };
83795     } catch (Dali::DaliException e) {
83796       {
83797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83798       };
83799     } catch (...) {
83800       {
83801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83802       };
83803     }
83804   }
83805
83806   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83807   return jresult;
83808 }
83809
83810
83811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
83812   void * jresult ;
83813   unsigned int arg1 ;
83814   float arg2 ;
83815   Dali::Pixel::Format arg3 ;
83816   float arg4 ;
83817   float arg5 ;
83818   bool arg6 ;
83819   Dali::Toolkit::GaussianBlurView result;
83820
83821   arg1 = (unsigned int)jarg1;
83822   arg2 = (float)jarg2;
83823   arg3 = (Dali::Pixel::Format)jarg3;
83824   arg4 = (float)jarg4;
83825   arg5 = (float)jarg5;
83826   arg6 = jarg6 ? true : false;
83827   {
83828     try {
83829       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
83830     } catch (std::out_of_range& e) {
83831       {
83832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83833       };
83834     } catch (std::exception& e) {
83835       {
83836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83837       };
83838     } catch (Dali::DaliException e) {
83839       {
83840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83841       };
83842     } catch (...) {
83843       {
83844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83845       };
83846     }
83847   }
83848
83849   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83850   return jresult;
83851 }
83852
83853
83854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
83855   void * jresult ;
83856   unsigned int arg1 ;
83857   float arg2 ;
83858   Dali::Pixel::Format arg3 ;
83859   float arg4 ;
83860   float arg5 ;
83861   Dali::Toolkit::GaussianBlurView result;
83862
83863   arg1 = (unsigned int)jarg1;
83864   arg2 = (float)jarg2;
83865   arg3 = (Dali::Pixel::Format)jarg3;
83866   arg4 = (float)jarg4;
83867   arg5 = (float)jarg5;
83868   {
83869     try {
83870       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
83871     } catch (std::out_of_range& e) {
83872       {
83873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83874       };
83875     } catch (std::exception& e) {
83876       {
83877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83878       };
83879     } catch (Dali::DaliException e) {
83880       {
83881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83882       };
83883     } catch (...) {
83884       {
83885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83886       };
83887     }
83888   }
83889
83890   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83891   return jresult;
83892 }
83893
83894
83895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
83896   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83897   Dali::Actor arg2 ;
83898   Dali::Actor *argp2 ;
83899
83900   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83901   argp2 = (Dali::Actor *)jarg2;
83902   if (!argp2) {
83903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83904     return ;
83905   }
83906   arg2 = *argp2;
83907   {
83908     try {
83909       (arg1)->Add(arg2);
83910     } catch (std::out_of_range& e) {
83911       {
83912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83913       };
83914     } catch (std::exception& e) {
83915       {
83916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83917       };
83918     } catch (Dali::DaliException e) {
83919       {
83920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83921       };
83922     } catch (...) {
83923       {
83924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83925       };
83926     }
83927   }
83928
83929 }
83930
83931
83932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
83933   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83934   Dali::Actor arg2 ;
83935   Dali::Actor *argp2 ;
83936
83937   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83938   argp2 = (Dali::Actor *)jarg2;
83939   if (!argp2) {
83940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83941     return ;
83942   }
83943   arg2 = *argp2;
83944   {
83945     try {
83946       (arg1)->Remove(arg2);
83947     } catch (std::out_of_range& e) {
83948       {
83949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83950       };
83951     } catch (std::exception& e) {
83952       {
83953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83954       };
83955     } catch (Dali::DaliException e) {
83956       {
83957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83958       };
83959     } catch (...) {
83960       {
83961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83962       };
83963     }
83964   }
83965
83966 }
83967
83968
83969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
83970   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83971
83972   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83973   {
83974     try {
83975       (arg1)->Activate();
83976     } catch (std::out_of_range& e) {
83977       {
83978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83979       };
83980     } catch (std::exception& e) {
83981       {
83982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83983       };
83984     } catch (Dali::DaliException e) {
83985       {
83986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83987       };
83988     } catch (...) {
83989       {
83990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83991       };
83992     }
83993   }
83994
83995 }
83996
83997
83998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
83999   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84000
84001   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84002   {
84003     try {
84004       (arg1)->ActivateOnce();
84005     } catch (std::out_of_range& e) {
84006       {
84007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84008       };
84009     } catch (std::exception& e) {
84010       {
84011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84012       };
84013     } catch (Dali::DaliException e) {
84014       {
84015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84016       };
84017     } catch (...) {
84018       {
84019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84020       };
84021     }
84022   }
84023
84024 }
84025
84026
84027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84028   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84029
84030   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84031   {
84032     try {
84033       (arg1)->Deactivate();
84034     } catch (std::out_of_range& e) {
84035       {
84036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84037       };
84038     } catch (std::exception& e) {
84039       {
84040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84041       };
84042     } catch (Dali::DaliException e) {
84043       {
84044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84045       };
84046     } catch (...) {
84047       {
84048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84049       };
84050     }
84051   }
84052
84053 }
84054
84055
84056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84057   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84058   Dali::Texture arg2 ;
84059   Dali::FrameBuffer arg3 ;
84060   Dali::Texture *argp2 ;
84061   Dali::FrameBuffer *argp3 ;
84062
84063   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84064   argp2 = (Dali::Texture *)jarg2;
84065   if (!argp2) {
84066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
84067     return ;
84068   }
84069   arg2 = *argp2;
84070   argp3 = (Dali::FrameBuffer *)jarg3;
84071   if (!argp3) {
84072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
84073     return ;
84074   }
84075   arg3 = *argp3;
84076   {
84077     try {
84078       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
84079     } catch (std::out_of_range& e) {
84080       {
84081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84082       };
84083     } catch (std::exception& e) {
84084       {
84085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84086       };
84087     } catch (Dali::DaliException e) {
84088       {
84089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84090       };
84091     } catch (...) {
84092       {
84093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84094       };
84095     }
84096   }
84097
84098 }
84099
84100
84101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84102   int jresult ;
84103   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84104   Dali::Property::Index result;
84105
84106   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84107   {
84108     try {
84109       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84110     } catch (std::out_of_range& e) {
84111       {
84112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84113       };
84114     } catch (std::exception& e) {
84115       {
84116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84117       };
84118     } catch (Dali::DaliException e) {
84119       {
84120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84121       };
84122     } catch (...) {
84123       {
84124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84125       };
84126     }
84127   }
84128
84129   jresult = result;
84130   return jresult;
84131 }
84132
84133
84134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84135   void * jresult ;
84136   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84137   Dali::FrameBuffer result;
84138
84139   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84140   {
84141     try {
84142       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84143     } catch (std::out_of_range& e) {
84144       {
84145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84146       };
84147     } catch (std::exception& e) {
84148       {
84149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84150       };
84151     } catch (Dali::DaliException e) {
84152       {
84153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84154       };
84155     } catch (...) {
84156       {
84157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84158       };
84159     }
84160   }
84161
84162   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
84163   return jresult;
84164 }
84165
84166
84167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84168   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84169   Dali::Vector4 *arg2 = 0 ;
84170
84171   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84172   arg2 = (Dali::Vector4 *)jarg2;
84173   if (!arg2) {
84174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84175     return ;
84176   }
84177   {
84178     try {
84179       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84180     } catch (std::out_of_range& e) {
84181       {
84182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84183       };
84184     } catch (std::exception& e) {
84185       {
84186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84187       };
84188     } catch (Dali::DaliException e) {
84189       {
84190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84191       };
84192     } catch (...) {
84193       {
84194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84195       };
84196     }
84197   }
84198
84199 }
84200
84201
84202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84203   void * jresult ;
84204   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84205   Dali::Vector4 result;
84206
84207   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84208   {
84209     try {
84210       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84211     } catch (std::out_of_range& e) {
84212       {
84213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84214       };
84215     } catch (std::exception& e) {
84216       {
84217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84218       };
84219     } catch (Dali::DaliException e) {
84220       {
84221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84222       };
84223     } catch (...) {
84224       {
84225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84226       };
84227     }
84228   }
84229
84230   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84231   return jresult;
84232 }
84233
84234
84235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84236   void * jresult ;
84237   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84238   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84239
84240   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84241   {
84242     try {
84243       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84244     } catch (std::out_of_range& e) {
84245       {
84246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84247       };
84248     } catch (std::exception& e) {
84249       {
84250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84251       };
84252     } catch (Dali::DaliException e) {
84253       {
84254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84255       };
84256     } catch (...) {
84257       {
84258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84259       };
84260     }
84261   }
84262
84263   jresult = (void *)result;
84264   return jresult;
84265 }
84266
84267
84268 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84269   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84270
84271   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84272   {
84273     try {
84274       delete arg1;
84275     } catch (std::out_of_range& e) {
84276       {
84277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84278       };
84279     } catch (std::exception& e) {
84280       {
84281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84282       };
84283     } catch (Dali::DaliException e) {
84284       {
84285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84286       };
84287     } catch (...) {
84288       {
84289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84290       };
84291     }
84292   }
84293
84294 }
84295
84296
84297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84298   unsigned int jresult ;
84299   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84300   unsigned int result;
84301
84302   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84303   {
84304     try {
84305       result = (unsigned int)(arg1)->GetNumberOfPages();
84306     } catch (std::out_of_range& e) {
84307       {
84308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84309       };
84310     } catch (std::exception& e) {
84311       {
84312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84313       };
84314     } catch (Dali::DaliException e) {
84315       {
84316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84317       };
84318     } catch (...) {
84319       {
84320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84321       };
84322     }
84323   }
84324
84325   jresult = result;
84326   return jresult;
84327 }
84328
84329
84330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84331   void * jresult ;
84332   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84333   unsigned int arg2 ;
84334   Dali::Texture result;
84335
84336   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84337   arg2 = (unsigned int)jarg2;
84338   {
84339     try {
84340       result = (arg1)->NewPage(arg2);
84341     } catch (std::out_of_range& e) {
84342       {
84343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84344       };
84345     } catch (std::exception& e) {
84346       {
84347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84348       };
84349     } catch (Dali::DaliException e) {
84350       {
84351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84352       };
84353     } catch (...) {
84354       {
84355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84356       };
84357     }
84358   }
84359
84360   jresult = new Dali::Texture((const Dali::Texture &)result);
84361   return jresult;
84362 }
84363
84364
84365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
84366   int jresult ;
84367   int result;
84368
84369   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
84370   jresult = (int)result;
84371   return jresult;
84372 }
84373
84374
84375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84376   int jresult ;
84377   int result;
84378
84379   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84380   jresult = (int)result;
84381   return jresult;
84382 }
84383
84384
84385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84386   int jresult ;
84387   int result;
84388
84389   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84390   jresult = (int)result;
84391   return jresult;
84392 }
84393
84394
84395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84396   void * jresult ;
84397   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84398
84399   {
84400     try {
84401       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84402     } catch (std::out_of_range& e) {
84403       {
84404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84405       };
84406     } catch (std::exception& e) {
84407       {
84408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84409       };
84410     } catch (Dali::DaliException e) {
84411       {
84412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84413       };
84414     } catch (...) {
84415       {
84416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84417       };
84418     }
84419   }
84420
84421   jresult = (void *)result;
84422   return jresult;
84423 }
84424
84425
84426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84427   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84428
84429   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84430   {
84431     try {
84432       delete arg1;
84433     } catch (std::out_of_range& e) {
84434       {
84435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84436       };
84437     } catch (std::exception& e) {
84438       {
84439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84440       };
84441     } catch (Dali::DaliException e) {
84442       {
84443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84444       };
84445     } catch (...) {
84446       {
84447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84448       };
84449     }
84450   }
84451
84452 }
84453
84454
84455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84456   void * jresult ;
84457   Dali::Toolkit::PageTurnView *result = 0 ;
84458
84459   {
84460     try {
84461       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84462     } catch (std::out_of_range& e) {
84463       {
84464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84465       };
84466     } catch (std::exception& e) {
84467       {
84468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84469       };
84470     } catch (Dali::DaliException e) {
84471       {
84472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84473       };
84474     } catch (...) {
84475       {
84476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84477       };
84478     }
84479   }
84480
84481   jresult = (void *)result;
84482   return jresult;
84483 }
84484
84485
84486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84487   void * jresult ;
84488   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84489   Dali::Toolkit::PageTurnView *result = 0 ;
84490
84491   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84492   if (!arg1) {
84493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84494     return 0;
84495   }
84496   {
84497     try {
84498       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84499     } catch (std::out_of_range& e) {
84500       {
84501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84502       };
84503     } catch (std::exception& e) {
84504       {
84505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84506       };
84507     } catch (Dali::DaliException e) {
84508       {
84509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84510       };
84511     } catch (...) {
84512       {
84513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84514       };
84515     }
84516   }
84517
84518   jresult = (void *)result;
84519   return jresult;
84520 }
84521
84522
84523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84524   void * jresult ;
84525   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84526   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84527   Dali::Toolkit::PageTurnView *result = 0 ;
84528
84529   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84530   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84531   if (!arg2) {
84532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84533     return 0;
84534   }
84535   {
84536     try {
84537       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84538     } catch (std::out_of_range& e) {
84539       {
84540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84541       };
84542     } catch (std::exception& e) {
84543       {
84544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84545       };
84546     } catch (Dali::DaliException e) {
84547       {
84548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84549       };
84550     } catch (...) {
84551       {
84552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84553       };
84554     }
84555   }
84556
84557   jresult = (void *)result;
84558   return jresult;
84559 }
84560
84561
84562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84563   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84564
84565   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84566   {
84567     try {
84568       delete arg1;
84569     } catch (std::out_of_range& e) {
84570       {
84571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84572       };
84573     } catch (std::exception& e) {
84574       {
84575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84576       };
84577     } catch (Dali::DaliException e) {
84578       {
84579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84580       };
84581     } catch (...) {
84582       {
84583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84584       };
84585     }
84586   }
84587
84588 }
84589
84590
84591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84592   void * jresult ;
84593   Dali::BaseHandle arg1 ;
84594   Dali::BaseHandle *argp1 ;
84595   Dali::Toolkit::PageTurnView result;
84596
84597   argp1 = (Dali::BaseHandle *)jarg1;
84598   if (!argp1) {
84599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84600     return 0;
84601   }
84602   arg1 = *argp1;
84603   {
84604     try {
84605       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
84606     } catch (std::out_of_range& e) {
84607       {
84608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84609       };
84610     } catch (std::exception& e) {
84611       {
84612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84613       };
84614     } catch (Dali::DaliException e) {
84615       {
84616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84617       };
84618     } catch (...) {
84619       {
84620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84621       };
84622     }
84623   }
84624
84625   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84626   return jresult;
84627 }
84628
84629
84630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84631   void * jresult ;
84632   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84633   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84634
84635   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84636   {
84637     try {
84638       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
84639     } catch (std::out_of_range& e) {
84640       {
84641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84642       };
84643     } catch (std::exception& e) {
84644       {
84645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84646       };
84647     } catch (Dali::DaliException e) {
84648       {
84649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84650       };
84651     } catch (...) {
84652       {
84653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84654       };
84655     }
84656   }
84657
84658   jresult = (void *)result;
84659   return jresult;
84660 }
84661
84662
84663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84664   void * jresult ;
84665   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84666   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84667
84668   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84669   {
84670     try {
84671       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84672     } catch (std::out_of_range& e) {
84673       {
84674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84675       };
84676     } catch (std::exception& e) {
84677       {
84678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84679       };
84680     } catch (Dali::DaliException e) {
84681       {
84682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84683       };
84684     } catch (...) {
84685       {
84686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84687       };
84688     }
84689   }
84690
84691   jresult = (void *)result;
84692   return jresult;
84693 }
84694
84695
84696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
84697   void * jresult ;
84698   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84699   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84700
84701   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84702   {
84703     try {
84704       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84705     } catch (std::out_of_range& e) {
84706       {
84707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84708       };
84709     } catch (std::exception& e) {
84710       {
84711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84712       };
84713     } catch (Dali::DaliException e) {
84714       {
84715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84716       };
84717     } catch (...) {
84718       {
84719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84720       };
84721     }
84722   }
84723
84724   jresult = (void *)result;
84725   return jresult;
84726 }
84727
84728
84729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84730   void * jresult ;
84731   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84732   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84733
84734   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84735   {
84736     try {
84737       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84738     } catch (std::out_of_range& e) {
84739       {
84740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84741       };
84742     } catch (std::exception& e) {
84743       {
84744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84745       };
84746     } catch (Dali::DaliException e) {
84747       {
84748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84749       };
84750     } catch (...) {
84751       {
84752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84753       };
84754     }
84755   }
84756
84757   jresult = (void *)result;
84758   return jresult;
84759 }
84760
84761
84762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
84763   void * jresult ;
84764   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84765
84766   {
84767     try {
84768       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84769     } catch (std::out_of_range& e) {
84770       {
84771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84772       };
84773     } catch (std::exception& e) {
84774       {
84775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84776       };
84777     } catch (Dali::DaliException e) {
84778       {
84779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84780       };
84781     } catch (...) {
84782       {
84783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84784       };
84785     }
84786   }
84787
84788   jresult = (void *)result;
84789   return jresult;
84790 }
84791
84792
84793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84794   void * jresult ;
84795   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84796   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84797
84798   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84799   if (!arg1) {
84800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84801     return 0;
84802   }
84803   {
84804     try {
84805       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
84806     } catch (std::out_of_range& e) {
84807       {
84808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84809       };
84810     } catch (std::exception& e) {
84811       {
84812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84813       };
84814     } catch (Dali::DaliException e) {
84815       {
84816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84817       };
84818     } catch (...) {
84819       {
84820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84821       };
84822     }
84823   }
84824
84825   jresult = (void *)result;
84826   return jresult;
84827 }
84828
84829
84830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
84831   void * jresult ;
84832   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84833   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
84834   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84835
84836   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84837   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
84838   if (!arg2) {
84839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84840     return 0;
84841   }
84842   {
84843     try {
84844       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
84845     } catch (std::out_of_range& e) {
84846       {
84847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84848       };
84849     } catch (std::exception& e) {
84850       {
84851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84852       };
84853     } catch (Dali::DaliException e) {
84854       {
84855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84856       };
84857     } catch (...) {
84858       {
84859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84860       };
84861     }
84862   }
84863
84864   jresult = (void *)result;
84865   return jresult;
84866 }
84867
84868
84869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
84870   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84871
84872   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84873   {
84874     try {
84875       delete arg1;
84876     } catch (std::out_of_range& e) {
84877       {
84878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84879       };
84880     } catch (std::exception& e) {
84881       {
84882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84883       };
84884     } catch (Dali::DaliException e) {
84885       {
84886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84887       };
84888     } catch (...) {
84889       {
84890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84891       };
84892     }
84893   }
84894
84895 }
84896
84897
84898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
84899   void * jresult ;
84900   Dali::Toolkit::PageFactory *arg1 = 0 ;
84901   Dali::Vector2 *arg2 = 0 ;
84902   Dali::Toolkit::PageTurnLandscapeView result;
84903
84904   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84905   if (!arg1) {
84906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84907     return 0;
84908   }
84909   arg2 = (Dali::Vector2 *)jarg2;
84910   if (!arg2) {
84911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84912     return 0;
84913   }
84914   {
84915     try {
84916       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
84917     } catch (std::out_of_range& e) {
84918       {
84919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84920       };
84921     } catch (std::exception& e) {
84922       {
84923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84924       };
84925     } catch (Dali::DaliException e) {
84926       {
84927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84928       };
84929     } catch (...) {
84930       {
84931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84932       };
84933     }
84934   }
84935
84936   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84937   return jresult;
84938 }
84939
84940
84941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
84942   void * jresult ;
84943   Dali::BaseHandle arg1 ;
84944   Dali::BaseHandle *argp1 ;
84945   Dali::Toolkit::PageTurnLandscapeView result;
84946
84947   argp1 = (Dali::BaseHandle *)jarg1;
84948   if (!argp1) {
84949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84950     return 0;
84951   }
84952   arg1 = *argp1;
84953   {
84954     try {
84955       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
84956     } catch (std::out_of_range& e) {
84957       {
84958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84959       };
84960     } catch (std::exception& e) {
84961       {
84962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84963       };
84964     } catch (Dali::DaliException e) {
84965       {
84966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84967       };
84968     } catch (...) {
84969       {
84970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84971       };
84972     }
84973   }
84974
84975   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84976   return jresult;
84977 }
84978
84979
84980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
84981   void * jresult ;
84982   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
84983
84984   {
84985     try {
84986       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
84987     } catch (std::out_of_range& e) {
84988       {
84989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84990       };
84991     } catch (std::exception& e) {
84992       {
84993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84994       };
84995     } catch (Dali::DaliException e) {
84996       {
84997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84998       };
84999     } catch (...) {
85000       {
85001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85002       };
85003     }
85004   }
85005
85006   jresult = (void *)result;
85007   return jresult;
85008 }
85009
85010
85011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
85012   void * jresult ;
85013   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
85014   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85015
85016   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85017   if (!arg1) {
85018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85019     return 0;
85020   }
85021   {
85022     try {
85023       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
85024     } catch (std::out_of_range& e) {
85025       {
85026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85027       };
85028     } catch (std::exception& e) {
85029       {
85030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85031       };
85032     } catch (Dali::DaliException e) {
85033       {
85034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85035       };
85036     } catch (...) {
85037       {
85038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85039       };
85040     }
85041   }
85042
85043   jresult = (void *)result;
85044   return jresult;
85045 }
85046
85047
85048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
85049   void * jresult ;
85050   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85051   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
85052   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85053
85054   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85055   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
85056   if (!arg2) {
85057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85058     return 0;
85059   }
85060   {
85061     try {
85062       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
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_PageTurnPortraitView(void * jarg1) {
85088   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85089
85090   arg1 = (Dali::Toolkit::PageTurnPortraitView *)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_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
85117   void * jresult ;
85118   Dali::Toolkit::PageFactory *arg1 = 0 ;
85119   Dali::Vector2 *arg2 = 0 ;
85120   Dali::Toolkit::PageTurnPortraitView result;
85121
85122   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85123   if (!arg1) {
85124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85125     return 0;
85126   }
85127   arg2 = (Dali::Vector2 *)jarg2;
85128   if (!arg2) {
85129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85130     return 0;
85131   }
85132   {
85133     try {
85134       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85135     } catch (std::out_of_range& e) {
85136       {
85137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85138       };
85139     } catch (std::exception& e) {
85140       {
85141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85142       };
85143     } catch (Dali::DaliException e) {
85144       {
85145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85146       };
85147     } catch (...) {
85148       {
85149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85150       };
85151     }
85152   }
85153
85154   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85155   return jresult;
85156 }
85157
85158
85159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85160   void * jresult ;
85161   Dali::BaseHandle arg1 ;
85162   Dali::BaseHandle *argp1 ;
85163   Dali::Toolkit::PageTurnPortraitView result;
85164
85165   argp1 = (Dali::BaseHandle *)jarg1;
85166   if (!argp1) {
85167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85168     return 0;
85169   }
85170   arg1 = *argp1;
85171   {
85172     try {
85173       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85174     } catch (std::out_of_range& e) {
85175       {
85176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85177       };
85178     } catch (std::exception& e) {
85179       {
85180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85181       };
85182     } catch (Dali::DaliException e) {
85183       {
85184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85185       };
85186     } catch (...) {
85187       {
85188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85189       };
85190     }
85191   }
85192
85193   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85194   return jresult;
85195 }
85196
85197
85198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85199   int jresult ;
85200   int result;
85201
85202   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85203   jresult = (int)result;
85204   return jresult;
85205 }
85206
85207
85208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85209   int jresult ;
85210   int result;
85211
85212   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85213   jresult = (int)result;
85214   return jresult;
85215 }
85216
85217
85218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85219   int jresult ;
85220   int result;
85221
85222   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85223   jresult = (int)result;
85224   return jresult;
85225 }
85226
85227
85228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85229   void * jresult ;
85230   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85231
85232   {
85233     try {
85234       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85235     } catch (std::out_of_range& e) {
85236       {
85237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85238       };
85239     } catch (std::exception& e) {
85240       {
85241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85242       };
85243     } catch (Dali::DaliException e) {
85244       {
85245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85246       };
85247     } catch (...) {
85248       {
85249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85250       };
85251     }
85252   }
85253
85254   jresult = (void *)result;
85255   return jresult;
85256 }
85257
85258
85259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85260   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85261
85262   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85263   {
85264     try {
85265       delete arg1;
85266     } catch (std::out_of_range& e) {
85267       {
85268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85269       };
85270     } catch (std::exception& e) {
85271       {
85272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85273       };
85274     } catch (Dali::DaliException e) {
85275       {
85276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85277       };
85278     } catch (...) {
85279       {
85280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85281       };
85282     }
85283   }
85284
85285 }
85286
85287
85288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85289   void * jresult ;
85290   Dali::Toolkit::ToggleButton *result = 0 ;
85291
85292   {
85293     try {
85294       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85295     } catch (std::out_of_range& e) {
85296       {
85297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85298       };
85299     } catch (std::exception& e) {
85300       {
85301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85302       };
85303     } catch (Dali::DaliException e) {
85304       {
85305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85306       };
85307     } catch (...) {
85308       {
85309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85310       };
85311     }
85312   }
85313
85314   jresult = (void *)result;
85315   return jresult;
85316 }
85317
85318
85319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85320   void * jresult ;
85321   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85322   Dali::Toolkit::ToggleButton *result = 0 ;
85323
85324   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85325   if (!arg1) {
85326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85327     return 0;
85328   }
85329   {
85330     try {
85331       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85332     } catch (std::out_of_range& e) {
85333       {
85334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85335       };
85336     } catch (std::exception& e) {
85337       {
85338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85339       };
85340     } catch (Dali::DaliException e) {
85341       {
85342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85343       };
85344     } catch (...) {
85345       {
85346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85347       };
85348     }
85349   }
85350
85351   jresult = (void *)result;
85352   return jresult;
85353 }
85354
85355
85356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85357   void * jresult ;
85358   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85359   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85360   Dali::Toolkit::ToggleButton *result = 0 ;
85361
85362   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85363   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85364   if (!arg2) {
85365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85366     return 0;
85367   }
85368   {
85369     try {
85370       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85371     } catch (std::out_of_range& e) {
85372       {
85373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85374       };
85375     } catch (std::exception& e) {
85376       {
85377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85378       };
85379     } catch (Dali::DaliException e) {
85380       {
85381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85382       };
85383     } catch (...) {
85384       {
85385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85386       };
85387     }
85388   }
85389
85390   jresult = (void *)result;
85391   return jresult;
85392 }
85393
85394
85395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85396   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85397
85398   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85399   {
85400     try {
85401       delete arg1;
85402     } catch (std::out_of_range& e) {
85403       {
85404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85405       };
85406     } catch (std::exception& e) {
85407       {
85408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85409       };
85410     } catch (Dali::DaliException e) {
85411       {
85412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85413       };
85414     } catch (...) {
85415       {
85416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85417       };
85418     }
85419   }
85420
85421 }
85422
85423
85424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85425   void * jresult ;
85426   Dali::Toolkit::ToggleButton result;
85427
85428   {
85429     try {
85430       result = Dali::Toolkit::ToggleButton::New();
85431     } catch (std::out_of_range& e) {
85432       {
85433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85434       };
85435     } catch (std::exception& e) {
85436       {
85437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85438       };
85439     } catch (Dali::DaliException e) {
85440       {
85441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85442       };
85443     } catch (...) {
85444       {
85445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85446       };
85447     }
85448   }
85449
85450   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85451   return jresult;
85452 }
85453
85454
85455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85456   void * jresult ;
85457   Dali::BaseHandle arg1 ;
85458   Dali::BaseHandle *argp1 ;
85459   Dali::Toolkit::ToggleButton result;
85460
85461   argp1 = (Dali::BaseHandle *)jarg1;
85462   if (!argp1) {
85463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85464     return 0;
85465   }
85466   arg1 = *argp1;
85467   {
85468     try {
85469       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
85470     } catch (std::out_of_range& e) {
85471       {
85472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85473       };
85474     } catch (std::exception& e) {
85475       {
85476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85477       };
85478     } catch (Dali::DaliException e) {
85479       {
85480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85481       };
85482     } catch (...) {
85483       {
85484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85485       };
85486     }
85487   }
85488
85489   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85490   return jresult;
85491 }
85492
85493
85494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85495   void * jresult ;
85496   Dali::Toolkit::Visual::Base *result = 0 ;
85497
85498   {
85499     try {
85500       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85501     } catch (std::out_of_range& e) {
85502       {
85503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85504       };
85505     } catch (std::exception& e) {
85506       {
85507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85508       };
85509     } catch (Dali::DaliException e) {
85510       {
85511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85512       };
85513     } catch (...) {
85514       {
85515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85516       };
85517     }
85518   }
85519
85520   jresult = (void *)result;
85521   return jresult;
85522 }
85523
85524
85525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85526   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85527
85528   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85529   {
85530     try {
85531       delete arg1;
85532     } catch (std::out_of_range& e) {
85533       {
85534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85535       };
85536     } catch (std::exception& e) {
85537       {
85538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85539       };
85540     } catch (Dali::DaliException e) {
85541       {
85542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85543       };
85544     } catch (...) {
85545       {
85546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85547       };
85548     }
85549   }
85550
85551 }
85552
85553
85554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85555   void * jresult ;
85556   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85557   Dali::Toolkit::Visual::Base *result = 0 ;
85558
85559   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85560   if (!arg1) {
85561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85562     return 0;
85563   }
85564   {
85565     try {
85566       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85567     } catch (std::out_of_range& e) {
85568       {
85569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85570       };
85571     } catch (std::exception& e) {
85572       {
85573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85574       };
85575     } catch (Dali::DaliException e) {
85576       {
85577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85578       };
85579     } catch (...) {
85580       {
85581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85582       };
85583     }
85584   }
85585
85586   jresult = (void *)result;
85587   return jresult;
85588 }
85589
85590
85591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85592   void * jresult ;
85593   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85594   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85595   Dali::Toolkit::Visual::Base *result = 0 ;
85596
85597   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85598   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85599   if (!arg2) {
85600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85601     return 0;
85602   }
85603   {
85604     try {
85605       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
85606     } catch (std::out_of_range& e) {
85607       {
85608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85609       };
85610     } catch (std::exception& e) {
85611       {
85612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85613       };
85614     } catch (Dali::DaliException e) {
85615       {
85616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85617       };
85618     } catch (...) {
85619       {
85620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85621       };
85622     }
85623   }
85624
85625   jresult = (void *)result;
85626   return jresult;
85627 }
85628
85629
85630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85631   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85632   std::string *arg2 = 0 ;
85633
85634   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85635   if (!jarg2) {
85636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85637     return ;
85638   }
85639   std::string arg2_str(jarg2);
85640   arg2 = &arg2_str;
85641   {
85642     try {
85643       (arg1)->SetName((std::string const &)*arg2);
85644     } catch (std::out_of_range& e) {
85645       {
85646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85647       };
85648     } catch (std::exception& e) {
85649       {
85650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85651       };
85652     } catch (Dali::DaliException e) {
85653       {
85654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85655       };
85656     } catch (...) {
85657       {
85658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85659       };
85660     }
85661   }
85662
85663
85664   //argout typemap for const std::string&
85665
85666 }
85667
85668
85669 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
85670   char * jresult ;
85671   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85672   std::string *result = 0 ;
85673
85674   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85675   {
85676     try {
85677       result = (std::string *) &(arg1)->GetName();
85678     } catch (std::out_of_range& e) {
85679       {
85680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85681       };
85682     } catch (std::exception& e) {
85683       {
85684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85685       };
85686     } catch (Dali::DaliException e) {
85687       {
85688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85689       };
85690     } catch (...) {
85691       {
85692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85693       };
85694     }
85695   }
85696
85697   jresult = SWIG_csharp_string_callback(result->c_str());
85698   return jresult;
85699 }
85700
85701
85702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
85703   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85704   Dali::Property::Map *arg2 = 0 ;
85705   Dali::Size arg3 ;
85706   Dali::Size *argp3 ;
85707
85708   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85709   arg2 = (Dali::Property::Map *)jarg2;
85710   if (!arg2) {
85711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85712     return ;
85713   }
85714   argp3 = (Dali::Size *)jarg3;
85715   if (!argp3) {
85716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
85717     return ;
85718   }
85719   arg3 = *argp3;
85720   {
85721     try {
85722       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
85723     } catch (std::out_of_range& e) {
85724       {
85725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85726       };
85727     } catch (std::exception& e) {
85728       {
85729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85730       };
85731     } catch (Dali::DaliException e) {
85732       {
85733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85734       };
85735     } catch (...) {
85736       {
85737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85738       };
85739     }
85740   }
85741
85742 }
85743
85744
85745 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
85746   float jresult ;
85747   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85748   float arg2 ;
85749   float result;
85750
85751   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85752   arg2 = (float)jarg2;
85753   {
85754     try {
85755       result = (float)(arg1)->GetHeightForWidth(arg2);
85756     } catch (std::out_of_range& e) {
85757       {
85758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85759       };
85760     } catch (std::exception& e) {
85761       {
85762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85763       };
85764     } catch (Dali::DaliException e) {
85765       {
85766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85767       };
85768     } catch (...) {
85769       {
85770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85771       };
85772     }
85773   }
85774
85775   jresult = result;
85776   return jresult;
85777 }
85778
85779
85780 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
85781   float jresult ;
85782   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85783   float arg2 ;
85784   float result;
85785
85786   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85787   arg2 = (float)jarg2;
85788   {
85789     try {
85790       result = (float)(arg1)->GetWidthForHeight(arg2);
85791     } catch (std::out_of_range& e) {
85792       {
85793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85794       };
85795     } catch (std::exception& e) {
85796       {
85797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85798       };
85799     } catch (Dali::DaliException e) {
85800       {
85801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85802       };
85803     } catch (...) {
85804       {
85805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85806       };
85807     }
85808   }
85809
85810   jresult = result;
85811   return jresult;
85812 }
85813
85814
85815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
85816   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85817   Dali::Vector2 *arg2 = 0 ;
85818
85819   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85820   arg2 = (Dali::Vector2 *)jarg2;
85821   if (!arg2) {
85822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
85823     return ;
85824   }
85825   {
85826     try {
85827       (arg1)->GetNaturalSize(*arg2);
85828     } catch (std::out_of_range& e) {
85829       {
85830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85831       };
85832     } catch (std::exception& e) {
85833       {
85834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85835       };
85836     } catch (Dali::DaliException e) {
85837       {
85838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85839       };
85840     } catch (...) {
85841       {
85842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85843       };
85844     }
85845   }
85846
85847 }
85848
85849
85850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
85851   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85852   float arg2 ;
85853
85854   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85855   arg2 = (int)jarg2;
85856   {
85857     try {
85858       (arg1)->SetDepthIndex(arg2);
85859     } catch (std::out_of_range& e) {
85860       {
85861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85862       };
85863     } catch (std::exception& e) {
85864       {
85865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85866       };
85867     } catch (Dali::DaliException e) {
85868       {
85869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85870       };
85871     } catch (...) {
85872       {
85873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85874       };
85875     }
85876   }
85877
85878 }
85879
85880
85881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
85882   int jresult ;
85883   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85884   int result;
85885
85886   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85887   {
85888     try {
85889       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
85890     } catch (std::out_of_range& e) {
85891       {
85892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85893       };
85894     } catch (std::exception& e) {
85895       {
85896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85897       };
85898     } catch (Dali::DaliException e) {
85899       {
85900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85901       };
85902     } catch (...) {
85903       {
85904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85905       };
85906     }
85907   }
85908
85909   jresult = result;
85910   return jresult;
85911 }
85912
85913
85914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
85915   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85916   Dali::Property::Map *arg2 = 0 ;
85917
85918   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85919   arg2 = (Dali::Property::Map *)jarg2;
85920   if (!arg2) {
85921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
85922     return ;
85923   }
85924   {
85925     try {
85926       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
85927     } catch (std::out_of_range& e) {
85928       {
85929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85930       };
85931     } catch (std::exception& e) {
85932       {
85933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85934       };
85935     } catch (Dali::DaliException e) {
85936       {
85937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85938       };
85939     } catch (...) {
85940       {
85941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85942       };
85943     }
85944   }
85945
85946 }
85947
85948
85949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
85950   void * jresult ;
85951   Dali::Toolkit::VisualFactory result;
85952
85953   {
85954     try {
85955       result = Dali::Toolkit::VisualFactory::Get();
85956     } catch (std::out_of_range& e) {
85957       {
85958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85959       };
85960     } catch (std::exception& e) {
85961       {
85962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85963       };
85964     } catch (Dali::DaliException e) {
85965       {
85966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85967       };
85968     } catch (...) {
85969       {
85970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85971       };
85972     }
85973   }
85974
85975   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
85976   return jresult;
85977 }
85978
85979
85980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
85981   void * jresult ;
85982   Dali::Toolkit::VisualFactory *result = 0 ;
85983
85984   {
85985     try {
85986       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
85987     } catch (std::out_of_range& e) {
85988       {
85989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85990       };
85991     } catch (std::exception& e) {
85992       {
85993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85994       };
85995     } catch (Dali::DaliException e) {
85996       {
85997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85998       };
85999     } catch (...) {
86000       {
86001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86002       };
86003     }
86004   }
86005
86006   jresult = (void *)result;
86007   return jresult;
86008 }
86009
86010
86011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
86012   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86013
86014   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86015   {
86016     try {
86017       delete arg1;
86018     } catch (std::out_of_range& e) {
86019       {
86020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86021       };
86022     } catch (std::exception& e) {
86023       {
86024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86025       };
86026     } catch (Dali::DaliException e) {
86027       {
86028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86029       };
86030     } catch (...) {
86031       {
86032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86033       };
86034     }
86035   }
86036
86037 }
86038
86039
86040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
86041   void * jresult ;
86042   Dali::Toolkit::VisualFactory *arg1 = 0 ;
86043   Dali::Toolkit::VisualFactory *result = 0 ;
86044
86045   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86046   if (!arg1) {
86047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86048     return 0;
86049   }
86050   {
86051     try {
86052       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
86053     } catch (std::out_of_range& e) {
86054       {
86055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86056       };
86057     } catch (std::exception& e) {
86058       {
86059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86060       };
86061     } catch (Dali::DaliException e) {
86062       {
86063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86064       };
86065     } catch (...) {
86066       {
86067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86068       };
86069     }
86070   }
86071
86072   jresult = (void *)result;
86073   return jresult;
86074 }
86075
86076
86077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
86078   void * jresult ;
86079   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86080   Dali::Toolkit::VisualFactory *arg2 = 0 ;
86081   Dali::Toolkit::VisualFactory *result = 0 ;
86082
86083   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86084   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
86085   if (!arg2) {
86086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86087     return 0;
86088   }
86089   {
86090     try {
86091       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
86092     } catch (std::out_of_range& e) {
86093       {
86094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86095       };
86096     } catch (std::exception& e) {
86097       {
86098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86099       };
86100     } catch (Dali::DaliException e) {
86101       {
86102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86103       };
86104     } catch (...) {
86105       {
86106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86107       };
86108     }
86109   }
86110
86111   jresult = (void *)result;
86112   return jresult;
86113 }
86114
86115
86116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
86117   void * jresult ;
86118   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86119   Dali::Property::Map *arg2 = 0 ;
86120   Dali::Toolkit::Visual::Base result;
86121
86122   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86123   arg2 = (Dali::Property::Map *)jarg2;
86124   if (!arg2) {
86125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86126     return 0;
86127   }
86128   {
86129     try {
86130       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
86131     } catch (std::out_of_range& e) {
86132       {
86133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86134       };
86135     } catch (std::exception& e) {
86136       {
86137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86138       };
86139     } catch (Dali::DaliException e) {
86140       {
86141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86142       };
86143     } catch (...) {
86144       {
86145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86146       };
86147     }
86148   }
86149
86150   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86151   return jresult;
86152 }
86153
86154
86155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
86156   void * jresult ;
86157   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86158   std::string *arg2 = 0 ;
86159   Dali::ImageDimensions arg3 ;
86160   Dali::ImageDimensions *argp3 ;
86161   Dali::Toolkit::Visual::Base result;
86162
86163   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86164   if (!jarg2) {
86165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86166     return 0;
86167   }
86168   std::string arg2_str(jarg2);
86169   arg2 = &arg2_str;
86170   argp3 = (Dali::ImageDimensions *)jarg3;
86171   if (!argp3) {
86172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86173     return 0;
86174   }
86175   arg3 = *argp3;
86176   {
86177     try {
86178       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
86179     } catch (std::out_of_range& e) {
86180       {
86181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86182       };
86183     } catch (std::exception& e) {
86184       {
86185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86186       };
86187     } catch (Dali::DaliException e) {
86188       {
86189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86190       };
86191     } catch (...) {
86192       {
86193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86194       };
86195     }
86196   }
86197
86198   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86199
86200   //argout typemap for const std::string&
86201
86202   return jresult;
86203 }
86204
86205
86206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
86207   void * jresult ;
86208   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86209
86210   {
86211     try {
86212       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
86213     } catch (std::out_of_range& e) {
86214       {
86215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86216       };
86217     } catch (std::exception& e) {
86218       {
86219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86220       };
86221     } catch (Dali::DaliException e) {
86222       {
86223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86224       };
86225     } catch (...) {
86226       {
86227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86228       };
86229     }
86230   }
86231
86232   jresult = (void *)result;
86233   return jresult;
86234 }
86235
86236
86237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86238   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86239
86240   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86241   {
86242     try {
86243       delete arg1;
86244     } catch (std::out_of_range& e) {
86245       {
86246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86247       };
86248     } catch (std::exception& e) {
86249       {
86250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86251       };
86252     } catch (Dali::DaliException e) {
86253       {
86254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86255       };
86256     } catch (...) {
86257       {
86258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86259       };
86260     }
86261   }
86262
86263 }
86264
86265
86266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86267   void * jresult ;
86268   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86269   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86270
86271   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86272   if (!arg1) {
86273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86274     return 0;
86275   }
86276   {
86277     try {
86278       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86279     } catch (std::out_of_range& e) {
86280       {
86281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86282       };
86283     } catch (std::exception& e) {
86284       {
86285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86286       };
86287     } catch (Dali::DaliException e) {
86288       {
86289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86290       };
86291     } catch (...) {
86292       {
86293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86294       };
86295     }
86296   }
86297
86298   jresult = (void *)result;
86299   return jresult;
86300 }
86301
86302
86303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86304   void * jresult ;
86305   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86306   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86307   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86308
86309   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86310   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86311   if (!arg2) {
86312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86313     return 0;
86314   }
86315   {
86316     try {
86317       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86318     } catch (std::out_of_range& e) {
86319       {
86320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86321       };
86322     } catch (std::exception& e) {
86323       {
86324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86325       };
86326     } catch (Dali::DaliException e) {
86327       {
86328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86329       };
86330     } catch (...) {
86331       {
86332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86333       };
86334     }
86335   }
86336
86337   jresult = (void *)result;
86338   return jresult;
86339 }
86340
86341
86342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86343   void * jresult ;
86344   Dali::Toolkit::AsyncImageLoader result;
86345
86346   {
86347     try {
86348       result = Dali::Toolkit::AsyncImageLoader::New();
86349     } catch (std::out_of_range& e) {
86350       {
86351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86352       };
86353     } catch (std::exception& e) {
86354       {
86355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86356       };
86357     } catch (Dali::DaliException e) {
86358       {
86359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86360       };
86361     } catch (...) {
86362       {
86363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86364       };
86365     }
86366   }
86367
86368   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86369   return jresult;
86370 }
86371
86372
86373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86374   void * jresult ;
86375   Dali::BaseHandle arg1 ;
86376   Dali::BaseHandle *argp1 ;
86377   Dali::Toolkit::AsyncImageLoader result;
86378
86379   argp1 = (Dali::BaseHandle *)jarg1;
86380   if (!argp1) {
86381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86382     return 0;
86383   }
86384   arg1 = *argp1;
86385   {
86386     try {
86387       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86388     } catch (std::out_of_range& e) {
86389       {
86390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86391       };
86392     } catch (std::exception& e) {
86393       {
86394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86395       };
86396     } catch (Dali::DaliException e) {
86397       {
86398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86399       };
86400     } catch (...) {
86401       {
86402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86403       };
86404     }
86405   }
86406
86407   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86408   return jresult;
86409 }
86410
86411
86412 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86413   unsigned int jresult ;
86414   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86415   std::string *arg2 = 0 ;
86416   uint32_t result;
86417
86418   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86419   if (!jarg2) {
86420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86421     return 0;
86422   }
86423   std::string arg2_str(jarg2);
86424   arg2 = &arg2_str;
86425   {
86426     try {
86427       result = (arg1)->Load((std::string const &)*arg2);
86428     } catch (std::out_of_range& e) {
86429       {
86430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86431       };
86432     } catch (std::exception& e) {
86433       {
86434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86435       };
86436     } catch (Dali::DaliException e) {
86437       {
86438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86439       };
86440     } catch (...) {
86441       {
86442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86443       };
86444     }
86445   }
86446
86447   jresult = result;
86448
86449   //argout typemap for const std::string&
86450
86451   return jresult;
86452 }
86453
86454
86455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86456   unsigned int jresult ;
86457   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86458   std::string *arg2 = 0 ;
86459   Dali::ImageDimensions arg3 ;
86460   Dali::ImageDimensions *argp3 ;
86461   uint32_t result;
86462
86463   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86464   if (!jarg2) {
86465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86466     return 0;
86467   }
86468   std::string arg2_str(jarg2);
86469   arg2 = &arg2_str;
86470   argp3 = (Dali::ImageDimensions *)jarg3;
86471   if (!argp3) {
86472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86473     return 0;
86474   }
86475   arg3 = *argp3;
86476   {
86477     try {
86478       result = (arg1)->Load((std::string const &)*arg2,arg3);
86479     } catch (std::out_of_range& e) {
86480       {
86481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86482       };
86483     } catch (std::exception& e) {
86484       {
86485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86486       };
86487     } catch (Dali::DaliException e) {
86488       {
86489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86490       };
86491     } catch (...) {
86492       {
86493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86494       };
86495     }
86496   }
86497
86498   jresult = result;
86499
86500   //argout typemap for const std::string&
86501
86502   return jresult;
86503 }
86504
86505
86506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86507   unsigned int jresult ;
86508   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86509   std::string *arg2 = 0 ;
86510   Dali::ImageDimensions arg3 ;
86511   Dali::FittingMode::Type arg4 ;
86512   Dali::SamplingMode::Type arg5 ;
86513   bool arg6 ;
86514   Dali::ImageDimensions *argp3 ;
86515   uint32_t result;
86516
86517   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86518   if (!jarg2) {
86519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86520     return 0;
86521   }
86522   std::string arg2_str(jarg2);
86523   arg2 = &arg2_str;
86524   argp3 = (Dali::ImageDimensions *)jarg3;
86525   if (!argp3) {
86526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86527     return 0;
86528   }
86529   arg3 = *argp3;
86530   arg4 = (Dali::FittingMode::Type)jarg4;
86531   arg5 = (Dali::SamplingMode::Type)jarg5;
86532   arg6 = jarg6 ? true : false;
86533   {
86534     try {
86535       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86536     } catch (std::out_of_range& e) {
86537       {
86538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86539       };
86540     } catch (std::exception& e) {
86541       {
86542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86543       };
86544     } catch (Dali::DaliException e) {
86545       {
86546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86547       };
86548     } catch (...) {
86549       {
86550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86551       };
86552     }
86553   }
86554
86555   jresult = result;
86556
86557   //argout typemap for const std::string&
86558
86559   return jresult;
86560 }
86561
86562
86563 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86564   unsigned int jresult ;
86565   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86566   uint32_t arg2 ;
86567   bool result;
86568
86569   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86570   arg2 = (uint32_t)jarg2;
86571   {
86572     try {
86573       result = (bool)(arg1)->Cancel(arg2);
86574     } catch (std::out_of_range& e) {
86575       {
86576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86577       };
86578     } catch (std::exception& e) {
86579       {
86580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86581       };
86582     } catch (Dali::DaliException e) {
86583       {
86584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86585       };
86586     } catch (...) {
86587       {
86588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86589       };
86590     }
86591   }
86592
86593   jresult = result;
86594   return jresult;
86595 }
86596
86597
86598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86599   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86600
86601   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86602   {
86603     try {
86604       (arg1)->CancelAll();
86605     } catch (std::out_of_range& e) {
86606       {
86607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86608       };
86609     } catch (std::exception& e) {
86610       {
86611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86612       };
86613     } catch (Dali::DaliException e) {
86614       {
86615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86616       };
86617     } catch (...) {
86618       {
86619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86620       };
86621     }
86622   }
86623
86624 }
86625
86626
86627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86628   void * jresult ;
86629   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86630   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86631
86632   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86633   {
86634     try {
86635       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
86636     } catch (std::out_of_range& e) {
86637       {
86638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86639       };
86640     } catch (std::exception& e) {
86641       {
86642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86643       };
86644     } catch (Dali::DaliException e) {
86645       {
86646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86647       };
86648     } catch (...) {
86649       {
86650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86651       };
86652     }
86653   }
86654
86655   jresult = (void *)result;
86656   return jresult;
86657 }
86658
86659
86660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
86661   void * jresult ;
86662   std::string *arg1 = 0 ;
86663   Dali::PixelData result;
86664
86665   if (!jarg1) {
86666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86667     return 0;
86668   }
86669   std::string arg1_str(jarg1);
86670   arg1 = &arg1_str;
86671   {
86672     try {
86673       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
86674     } catch (std::out_of_range& e) {
86675       {
86676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86677       };
86678     } catch (std::exception& e) {
86679       {
86680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86681       };
86682     } catch (Dali::DaliException e) {
86683       {
86684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86685       };
86686     } catch (...) {
86687       {
86688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86689       };
86690     }
86691   }
86692
86693   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86694
86695   //argout typemap for const std::string&
86696
86697   return jresult;
86698 }
86699
86700
86701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
86702   void * jresult ;
86703   std::string *arg1 = 0 ;
86704   Dali::ImageDimensions arg2 ;
86705   Dali::ImageDimensions *argp2 ;
86706   Dali::PixelData result;
86707
86708   if (!jarg1) {
86709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86710     return 0;
86711   }
86712   std::string arg1_str(jarg1);
86713   arg1 = &arg1_str;
86714   argp2 = (Dali::ImageDimensions *)jarg2;
86715   if (!argp2) {
86716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86717     return 0;
86718   }
86719   arg2 = *argp2;
86720   {
86721     try {
86722       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
86723     } catch (std::out_of_range& e) {
86724       {
86725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86726       };
86727     } catch (std::exception& e) {
86728       {
86729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86730       };
86731     } catch (Dali::DaliException e) {
86732       {
86733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86734       };
86735     } catch (...) {
86736       {
86737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86738       };
86739     }
86740   }
86741
86742   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86743
86744   //argout typemap for const std::string&
86745
86746   return jresult;
86747 }
86748
86749
86750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
86751   void * jresult ;
86752   std::string *arg1 = 0 ;
86753   Dali::ImageDimensions arg2 ;
86754   Dali::FittingMode::Type arg3 ;
86755   Dali::SamplingMode::Type arg4 ;
86756   bool arg5 ;
86757   Dali::ImageDimensions *argp2 ;
86758   Dali::PixelData result;
86759
86760   if (!jarg1) {
86761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86762     return 0;
86763   }
86764   std::string arg1_str(jarg1);
86765   arg1 = &arg1_str;
86766   argp2 = (Dali::ImageDimensions *)jarg2;
86767   if (!argp2) {
86768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86769     return 0;
86770   }
86771   arg2 = *argp2;
86772   arg3 = (Dali::FittingMode::Type)jarg3;
86773   arg4 = (Dali::SamplingMode::Type)jarg4;
86774   arg5 = jarg5 ? true : false;
86775   {
86776     try {
86777       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
86778     } catch (std::out_of_range& e) {
86779       {
86780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86781       };
86782     } catch (std::exception& e) {
86783       {
86784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86785       };
86786     } catch (Dali::DaliException e) {
86787       {
86788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86789       };
86790     } catch (...) {
86791       {
86792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86793       };
86794     }
86795   }
86796
86797   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86798
86799   //argout typemap for const std::string&
86800
86801   return jresult;
86802 }
86803
86804
86805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
86806   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86807
86808   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86809   {
86810     try {
86811       delete arg1;
86812     } catch (std::out_of_range& e) {
86813       {
86814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86815       };
86816     } catch (std::exception& e) {
86817       {
86818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86819       };
86820     } catch (Dali::DaliException e) {
86821       {
86822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86823       };
86824     } catch (...) {
86825       {
86826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86827       };
86828     }
86829   }
86830
86831 }
86832
86833
86834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
86835   void * jresult ;
86836   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86837   Dali::Actor arg2 ;
86838   Dali::Actor arg3 ;
86839   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
86840   Dali::Actor *argp2 ;
86841   Dali::Actor *argp3 ;
86842   Dali::Actor result;
86843
86844   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86845   argp2 = (Dali::Actor *)jarg2;
86846   if (!argp2) {
86847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86848     return 0;
86849   }
86850   arg2 = *argp2;
86851   argp3 = (Dali::Actor *)jarg3;
86852   if (!argp3) {
86853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86854     return 0;
86855   }
86856   arg3 = *argp3;
86857   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
86858   {
86859     try {
86860       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
86861     } catch (std::out_of_range& e) {
86862       {
86863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86864       };
86865     } catch (std::exception& e) {
86866       {
86867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86868       };
86869     } catch (Dali::DaliException e) {
86870       {
86871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86872       };
86873     } catch (...) {
86874       {
86875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86876       };
86877     }
86878   }
86879
86880   jresult = new Dali::Actor((const Dali::Actor &)result);
86881   return jresult;
86882 }
86883
86884
86885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
86886   void * jresult ;
86887   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
86888
86889   {
86890     try {
86891       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
86892     } catch (std::out_of_range& e) {
86893       {
86894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86895       };
86896     } catch (std::exception& e) {
86897       {
86898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86899       };
86900     } catch (Dali::DaliException e) {
86901       {
86902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86903       };
86904     } catch (...) {
86905       {
86906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86907       };
86908     }
86909   }
86910
86911   jresult = (void *)result;
86912   return jresult;
86913 }
86914
86915
86916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_director_connect(void *objarg, SwigDirector_FrameCallbackInterface::SWIG_Callback0_t callback0) {
86917   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)objarg;
86918   SwigDirector_FrameCallbackInterface *director = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
86919   if (director) {
86920     director->swig_connect_director(callback0);
86921   }
86922 }
86923
86924
86925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameCallbackInterface() {
86926   void * jresult ;
86927   Dali::FrameCallbackInterface *result = 0 ;
86928
86929   {
86930     try {
86931       result =(Dali::FrameCallbackInterface *) new SwigDirector_FrameCallbackInterface();
86932     } catch (std::out_of_range& e) {
86933       {
86934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86935       };
86936     } catch (std::exception& e) {
86937       {
86938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86939       };
86940     } catch (Dali::DaliException e) {
86941       {
86942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86943       };
86944     } catch (...) {
86945       {
86946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86947       };
86948     }
86949   }
86950
86951   jresult = (void *)result;
86952   return jresult;
86953 }
86954
86955 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPosition(void * updateProxy, unsigned int id,  void* position) {
86956   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86957   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
86958   return proxy->GetPosition(id, *vector3);
86959 }
86960
86961 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetPosition(void * updateProxy, unsigned int id, void* position) {
86962   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86963   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
86964   return proxy->SetPosition(id, *vector3);
86965 }
86966
86967 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakePosition(void * updateProxy, unsigned int id, void* position) {
86968   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86969   Dali::Vector3* vector3 = (Dali::Vector3 *)position;
86970   return proxy->BakePosition(id, *vector3);
86971 }
86972
86973 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetSize(void * updateProxy, unsigned int id, void* size) {
86974   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86975   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
86976   return proxy->GetSize(id, *vector3);
86977 }
86978
86979 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetSize(void * updateProxy, unsigned int id, void* size) {
86980   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86981   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
86982   return proxy->SetSize(id, *vector3);
86983 }
86984 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeSize(void * updateProxy, unsigned int id, void* size) {
86985   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86986   Dali::Vector3* vector3 = (Dali::Vector3 *)size;
86987   return proxy->BakeSize(id, *vector3);
86988 }
86989
86990 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetPositionAndSize(void * updateProxy, unsigned int id, void* position, void* size) {
86991   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86992   Dali::Vector3* vector3_pos = (Dali::Vector3 *)position;
86993   Dali::Vector3* vector3_size = (Dali::Vector3 *)size;
86994   return proxy->GetPositionAndSize(id, *vector3_pos, *vector3_size);
86995 }
86996
86997 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetScale(void * updateProxy, unsigned int id, void* scale) {
86998   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
86999   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87000   return proxy->GetScale(id,* vector3);
87001 }
87002
87003 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetScale(void * updateProxy, unsigned int id, void* scale) {
87004   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87005   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87006   return proxy->SetScale(id, *vector3);
87007 }
87008
87009 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeScale(void * updateProxy, unsigned int id, void* scale) {
87010   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87011   Dali::Vector3* vector3 = (Dali::Vector3 *)scale;
87012   return proxy->BakeScale(id, *vector3);
87013 }
87014
87015 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_GetColor(void * updateProxy, unsigned int id, void* color) {
87016   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87017   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87018   return proxy->GetColor(id, *vector4);
87019 }
87020
87021 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_SetColor(void * updateProxy, unsigned int id, void* color) {
87022   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87023   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87024   return proxy->SetColor(id, *vector4);
87025 }
87026
87027 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_BakeColor(void * updateProxy, unsigned int id, void* color) {
87028   Dali::UpdateProxy *proxy = (Dali::UpdateProxy*)updateProxy;
87029   Dali::Vector4* vector4 = (Dali::Vector4 *)color;
87030   return proxy->BakeColor(id, *vector4);
87031 }
87032
87033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_AddFrameCallback(void * jarg1, void* jarg2, void* jarg3) {
87034   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
87035   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87036
87037   Dali::Stage *arg1 = (Dali::Stage *) 0;
87038   Dali::Actor *arg3 = 0;
87039
87040   arg1 = (Dali::Stage *)jarg1;
87041   arg3 = (Dali::Actor *)jarg3;
87042
87043   DevelStage::AddFrameCallback( *arg1, *arg2, *arg3 );
87044   return;
87045 }
87046
87047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameCallbackInterface_RemoveFrameCallback(void * jarg1, void* jarg2) {
87048
87049   Dali::FrameCallbackInterface *obj = (Dali::FrameCallbackInterface *)jarg2;
87050   SwigDirector_FrameCallbackInterface *arg2 = dynamic_cast<SwigDirector_FrameCallbackInterface *>(obj);
87051
87052   Dali::Stage *arg1 = (Dali::Stage *) 0;
87053
87054   arg1 = (Dali::Stage *)jarg1;
87055
87056   DevelStage::RemoveFrameCallback( *arg1, *arg2 );
87057   return;
87058 }
87059
87060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
87061   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
87062   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
87063   if (director) {
87064     director->swig_connect_director(callback0);
87065   }
87066 }
87067
87068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
87069   KeyboardFocusManager arg1 ;
87070   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
87071   KeyboardFocusManager *argp1 ;
87072
87073   argp1 = (KeyboardFocusManager *)jarg1;
87074   if (!argp1) {
87075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
87076     return ;
87077   }
87078   arg1 = *argp1;
87079   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
87080   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
87081   {
87082     try {
87083       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
87084     } catch (std::out_of_range& e) {
87085       {
87086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87087       };
87088     } catch (std::exception& e) {
87089       {
87090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87091       };
87092     } catch (Dali::DaliException e) {
87093       {
87094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87095       };
87096     } catch (...) {
87097       {
87098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87099       };
87100     }
87101   }
87102
87103 }
87104
87105
87106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
87107   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87108
87109   arg1 = (std::vector< unsigned int > *)jarg1;
87110   {
87111     try {
87112       (arg1)->clear();
87113     } catch (std::out_of_range& e) {
87114       {
87115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87116       };
87117     } catch (std::exception& e) {
87118       {
87119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87120       };
87121     } catch (Dali::DaliException e) {
87122       {
87123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87124       };
87125     } catch (...) {
87126       {
87127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87128       };
87129     }
87130   }
87131
87132 }
87133
87134
87135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
87136   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87137   unsigned int *arg2 = 0 ;
87138   unsigned int temp2 ;
87139
87140   arg1 = (std::vector< unsigned int > *)jarg1;
87141   temp2 = (unsigned int)jarg2;
87142   arg2 = &temp2;
87143   {
87144     try {
87145       (arg1)->push_back((unsigned int const &)*arg2);
87146     } catch (std::out_of_range& e) {
87147       {
87148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87149       };
87150     } catch (std::exception& e) {
87151       {
87152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87153       };
87154     } catch (Dali::DaliException e) {
87155       {
87156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87157       };
87158     } catch (...) {
87159       {
87160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87161       };
87162     }
87163   }
87164
87165 }
87166
87167
87168 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
87169   unsigned long jresult ;
87170   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87171   std::vector< unsigned int >::size_type result;
87172
87173   arg1 = (std::vector< unsigned int > *)jarg1;
87174   {
87175     try {
87176       result = ((std::vector< unsigned int > const *)arg1)->size();
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 = (unsigned long)result;
87197   return jresult;
87198 }
87199
87200
87201 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
87202   unsigned long jresult ;
87203   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87204   std::vector< unsigned int >::size_type result;
87205
87206   arg1 = (std::vector< unsigned int > *)jarg1;
87207   {
87208     try {
87209       result = ((std::vector< unsigned int > const *)arg1)->capacity();
87210     } catch (std::out_of_range& e) {
87211       {
87212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87213       };
87214     } catch (std::exception& e) {
87215       {
87216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87217       };
87218     } catch (Dali::DaliException e) {
87219       {
87220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87221       };
87222     } catch (...) {
87223       {
87224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87225       };
87226     }
87227   }
87228
87229   jresult = (unsigned long)result;
87230   return jresult;
87231 }
87232
87233
87234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
87235   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87236   std::vector< unsigned int >::size_type arg2 ;
87237
87238   arg1 = (std::vector< unsigned int > *)jarg1;
87239   arg2 = (std::vector< unsigned int >::size_type)jarg2;
87240   {
87241     try {
87242       (arg1)->reserve(arg2);
87243     } catch (std::out_of_range& e) {
87244       {
87245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87246       };
87247     } catch (std::exception& e) {
87248       {
87249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87250       };
87251     } catch (Dali::DaliException e) {
87252       {
87253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87254       };
87255     } catch (...) {
87256       {
87257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87258       };
87259     }
87260   }
87261
87262 }
87263
87264
87265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
87266   void * jresult ;
87267   std::vector< unsigned int > *result = 0 ;
87268
87269   {
87270     try {
87271       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
87272     } catch (std::out_of_range& e) {
87273       {
87274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87275       };
87276     } catch (std::exception& e) {
87277       {
87278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87279       };
87280     } catch (Dali::DaliException e) {
87281       {
87282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87283       };
87284     } catch (...) {
87285       {
87286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87287       };
87288     }
87289   }
87290
87291   jresult = (void *)result;
87292   return jresult;
87293 }
87294
87295
87296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
87297   void * jresult ;
87298   std::vector< unsigned int > *arg1 = 0 ;
87299   std::vector< unsigned int > *result = 0 ;
87300
87301   arg1 = (std::vector< unsigned int > *)jarg1;
87302   if (!arg1) {
87303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87304     return 0;
87305   }
87306   {
87307     try {
87308       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
87309     } catch (std::out_of_range& e) {
87310       {
87311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87312       };
87313     } catch (std::exception& e) {
87314       {
87315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87316       };
87317     } catch (Dali::DaliException e) {
87318       {
87319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87320       };
87321     } catch (...) {
87322       {
87323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87324       };
87325     }
87326   }
87327
87328   jresult = (void *)result;
87329   return jresult;
87330 }
87331
87332
87333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
87334   void * jresult ;
87335   int arg1 ;
87336   std::vector< unsigned int > *result = 0 ;
87337
87338   arg1 = (int)jarg1;
87339   {
87340     try {
87341       try {
87342         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
87343       }
87344       catch(std::out_of_range &_e) {
87345         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87346         return 0;
87347       }
87348
87349     } catch (std::out_of_range& e) {
87350       {
87351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87352       };
87353     } catch (std::exception& e) {
87354       {
87355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87356       };
87357     } catch (Dali::DaliException e) {
87358       {
87359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87360       };
87361     } catch (...) {
87362       {
87363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87364       };
87365     }
87366   }
87367
87368   jresult = (void *)result;
87369   return jresult;
87370 }
87371
87372
87373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
87374   unsigned int jresult ;
87375   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87376   int arg2 ;
87377   unsigned int result;
87378
87379   arg1 = (std::vector< unsigned int > *)jarg1;
87380   arg2 = (int)jarg2;
87381   {
87382     try {
87383       try {
87384         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
87385       }
87386       catch(std::out_of_range &_e) {
87387         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87388         return 0;
87389       }
87390
87391     } catch (std::out_of_range& e) {
87392       {
87393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87394       };
87395     } catch (std::exception& e) {
87396       {
87397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87398       };
87399     } catch (Dali::DaliException e) {
87400       {
87401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87402       };
87403     } catch (...) {
87404       {
87405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87406       };
87407     }
87408   }
87409
87410   jresult = result;
87411   return jresult;
87412 }
87413
87414
87415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
87416   unsigned int jresult ;
87417   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87418   int arg2 ;
87419   unsigned int *result = 0 ;
87420
87421   arg1 = (std::vector< unsigned int > *)jarg1;
87422   arg2 = (int)jarg2;
87423   {
87424     try {
87425       try {
87426         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
87427       }
87428       catch(std::out_of_range &_e) {
87429         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87430         return 0;
87431       }
87432
87433     } catch (std::out_of_range& e) {
87434       {
87435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87436       };
87437     } catch (std::exception& e) {
87438       {
87439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87440       };
87441     } catch (Dali::DaliException e) {
87442       {
87443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87444       };
87445     } catch (...) {
87446       {
87447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87448       };
87449     }
87450   }
87451
87452   jresult = *result;
87453   return jresult;
87454 }
87455
87456
87457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
87458   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87459   int arg2 ;
87460   unsigned int *arg3 = 0 ;
87461   unsigned int temp3 ;
87462
87463   arg1 = (std::vector< unsigned int > *)jarg1;
87464   arg2 = (int)jarg2;
87465   temp3 = (unsigned int)jarg3;
87466   arg3 = &temp3;
87467   {
87468     try {
87469       try {
87470         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87471       }
87472       catch(std::out_of_range &_e) {
87473         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87474         return ;
87475       }
87476
87477     } catch (std::out_of_range& e) {
87478       {
87479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87480       };
87481     } catch (std::exception& e) {
87482       {
87483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87484       };
87485     } catch (Dali::DaliException e) {
87486       {
87487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87488       };
87489     } catch (...) {
87490       {
87491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87492       };
87493     }
87494   }
87495
87496 }
87497
87498
87499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87500   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87501   std::vector< unsigned int > *arg2 = 0 ;
87502
87503   arg1 = (std::vector< unsigned int > *)jarg1;
87504   arg2 = (std::vector< unsigned int > *)jarg2;
87505   if (!arg2) {
87506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87507     return ;
87508   }
87509   {
87510     try {
87511       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
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_GetRange(void * jarg1, int jarg2, int jarg3) {
87535   void * jresult ;
87536   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87537   int arg2 ;
87538   int arg3 ;
87539   std::vector< unsigned int > *result = 0 ;
87540
87541   arg1 = (std::vector< unsigned int > *)jarg1;
87542   arg2 = (int)jarg2;
87543   arg3 = (int)jarg3;
87544   {
87545     try {
87546       try {
87547         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87548       }
87549       catch(std::out_of_range &_e) {
87550         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87551         return 0;
87552       }
87553       catch(std::invalid_argument &_e) {
87554         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87555         return 0;
87556       }
87557
87558     } catch (std::out_of_range& e) {
87559       {
87560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87561       };
87562     } catch (std::exception& e) {
87563       {
87564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87565       };
87566     } catch (Dali::DaliException e) {
87567       {
87568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87569       };
87570     } catch (...) {
87571       {
87572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87573       };
87574     }
87575   }
87576
87577   jresult = (void *)result;
87578   return jresult;
87579 }
87580
87581
87582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87583   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87584   int arg2 ;
87585   unsigned int *arg3 = 0 ;
87586   unsigned int temp3 ;
87587
87588   arg1 = (std::vector< unsigned int > *)jarg1;
87589   arg2 = (int)jarg2;
87590   temp3 = (unsigned int)jarg3;
87591   arg3 = &temp3;
87592   {
87593     try {
87594       try {
87595         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87596       }
87597       catch(std::out_of_range &_e) {
87598         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87599         return ;
87600       }
87601
87602     } catch (std::out_of_range& e) {
87603       {
87604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87605       };
87606     } catch (std::exception& e) {
87607       {
87608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87609       };
87610     } catch (Dali::DaliException e) {
87611       {
87612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87613       };
87614     } catch (...) {
87615       {
87616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87617       };
87618     }
87619   }
87620
87621 }
87622
87623
87624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87625   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87626   int arg2 ;
87627   std::vector< unsigned int > *arg3 = 0 ;
87628
87629   arg1 = (std::vector< unsigned int > *)jarg1;
87630   arg2 = (int)jarg2;
87631   arg3 = (std::vector< unsigned int > *)jarg3;
87632   if (!arg3) {
87633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87634     return ;
87635   }
87636   {
87637     try {
87638       try {
87639         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87640       }
87641       catch(std::out_of_range &_e) {
87642         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87643         return ;
87644       }
87645
87646     } catch (std::out_of_range& e) {
87647       {
87648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87649       };
87650     } catch (std::exception& e) {
87651       {
87652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87653       };
87654     } catch (Dali::DaliException e) {
87655       {
87656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87657       };
87658     } catch (...) {
87659       {
87660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87661       };
87662     }
87663   }
87664
87665 }
87666
87667
87668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
87669   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87670   int arg2 ;
87671
87672   arg1 = (std::vector< unsigned int > *)jarg1;
87673   arg2 = (int)jarg2;
87674   {
87675     try {
87676       try {
87677         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
87678       }
87679       catch(std::out_of_range &_e) {
87680         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87681         return ;
87682       }
87683
87684     } catch (std::out_of_range& e) {
87685       {
87686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87687       };
87688     } catch (std::exception& e) {
87689       {
87690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87691       };
87692     } catch (Dali::DaliException e) {
87693       {
87694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87695       };
87696     } catch (...) {
87697       {
87698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87699       };
87700     }
87701   }
87702
87703 }
87704
87705
87706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87707   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87708   int arg2 ;
87709   int arg3 ;
87710
87711   arg1 = (std::vector< unsigned int > *)jarg1;
87712   arg2 = (int)jarg2;
87713   arg3 = (int)jarg3;
87714   {
87715     try {
87716       try {
87717         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
87718       }
87719       catch(std::out_of_range &_e) {
87720         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87721         return ;
87722       }
87723       catch(std::invalid_argument &_e) {
87724         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87725         return ;
87726       }
87727
87728     } catch (std::out_of_range& e) {
87729       {
87730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87731       };
87732     } catch (std::exception& e) {
87733       {
87734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87735       };
87736     } catch (Dali::DaliException e) {
87737       {
87738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87739       };
87740     } catch (...) {
87741       {
87742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87743       };
87744     }
87745   }
87746
87747 }
87748
87749
87750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
87751   void * jresult ;
87752   unsigned int *arg1 = 0 ;
87753   int arg2 ;
87754   unsigned int temp1 ;
87755   std::vector< unsigned int > *result = 0 ;
87756
87757   temp1 = (unsigned int)jarg1;
87758   arg1 = &temp1;
87759   arg2 = (int)jarg2;
87760   {
87761     try {
87762       try {
87763         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
87764       }
87765       catch(std::out_of_range &_e) {
87766         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87767         return 0;
87768       }
87769
87770     } catch (std::out_of_range& e) {
87771       {
87772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87773       };
87774     } catch (std::exception& e) {
87775       {
87776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87777       };
87778     } catch (Dali::DaliException e) {
87779       {
87780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87781       };
87782     } catch (...) {
87783       {
87784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87785       };
87786     }
87787   }
87788
87789   jresult = (void *)result;
87790   return jresult;
87791 }
87792
87793
87794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
87795   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87796
87797   arg1 = (std::vector< unsigned int > *)jarg1;
87798   {
87799     try {
87800       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
87801     } catch (std::out_of_range& e) {
87802       {
87803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87804       };
87805     } catch (std::exception& e) {
87806       {
87807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87808       };
87809     } catch (Dali::DaliException e) {
87810       {
87811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87812       };
87813     } catch (...) {
87814       {
87815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87816       };
87817     }
87818   }
87819
87820 }
87821
87822
87823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87824   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87825   int arg2 ;
87826   int arg3 ;
87827
87828   arg1 = (std::vector< unsigned int > *)jarg1;
87829   arg2 = (int)jarg2;
87830   arg3 = (int)jarg3;
87831   {
87832     try {
87833       try {
87834         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87835       }
87836       catch(std::out_of_range &_e) {
87837         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87838         return ;
87839       }
87840       catch(std::invalid_argument &_e) {
87841         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87842         return ;
87843       }
87844
87845     } catch (std::out_of_range& e) {
87846       {
87847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87848       };
87849     } catch (std::exception& e) {
87850       {
87851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87852       };
87853     } catch (Dali::DaliException e) {
87854       {
87855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87856       };
87857     } catch (...) {
87858       {
87859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87860       };
87861     }
87862   }
87863
87864 }
87865
87866
87867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87868   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87869   int arg2 ;
87870   std::vector< unsigned int > *arg3 = 0 ;
87871
87872   arg1 = (std::vector< unsigned int > *)jarg1;
87873   arg2 = (int)jarg2;
87874   arg3 = (std::vector< unsigned int > *)jarg3;
87875   if (!arg3) {
87876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87877     return ;
87878   }
87879   {
87880     try {
87881       try {
87882         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87883       }
87884       catch(std::out_of_range &_e) {
87885         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87886         return ;
87887       }
87888
87889     } catch (std::out_of_range& e) {
87890       {
87891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87892       };
87893     } catch (std::exception& e) {
87894       {
87895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87896       };
87897     } catch (Dali::DaliException e) {
87898       {
87899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87900       };
87901     } catch (...) {
87902       {
87903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87904       };
87905     }
87906   }
87907
87908 }
87909
87910
87911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
87912   unsigned int jresult ;
87913   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87914   unsigned int *arg2 = 0 ;
87915   unsigned int temp2 ;
87916   bool result;
87917
87918   arg1 = (std::vector< unsigned int > *)jarg1;
87919   temp2 = (unsigned int)jarg2;
87920   arg2 = &temp2;
87921   {
87922     try {
87923       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
87924     } catch (std::out_of_range& e) {
87925       {
87926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87927       };
87928     } catch (std::exception& e) {
87929       {
87930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87931       };
87932     } catch (Dali::DaliException e) {
87933       {
87934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87935       };
87936     } catch (...) {
87937       {
87938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87939       };
87940     }
87941   }
87942
87943   jresult = result;
87944   return jresult;
87945 }
87946
87947
87948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
87949   int jresult ;
87950   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87951   unsigned int *arg2 = 0 ;
87952   unsigned int temp2 ;
87953   int result;
87954
87955   arg1 = (std::vector< unsigned int > *)jarg1;
87956   temp2 = (unsigned int)jarg2;
87957   arg2 = &temp2;
87958   {
87959     try {
87960       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
87961     } catch (std::out_of_range& e) {
87962       {
87963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87964       };
87965     } catch (std::exception& e) {
87966       {
87967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87968       };
87969     } catch (Dali::DaliException e) {
87970       {
87971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87972       };
87973     } catch (...) {
87974       {
87975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87976       };
87977     }
87978   }
87979
87980   jresult = result;
87981   return jresult;
87982 }
87983
87984
87985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
87986   int jresult ;
87987   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87988   unsigned int *arg2 = 0 ;
87989   unsigned int temp2 ;
87990   int result;
87991
87992   arg1 = (std::vector< unsigned int > *)jarg1;
87993   temp2 = (unsigned int)jarg2;
87994   arg2 = &temp2;
87995   {
87996     try {
87997       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
87998     } catch (std::out_of_range& e) {
87999       {
88000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88001       };
88002     } catch (std::exception& e) {
88003       {
88004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88005       };
88006     } catch (Dali::DaliException e) {
88007       {
88008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88009       };
88010     } catch (...) {
88011       {
88012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88013       };
88014     }
88015   }
88016
88017   jresult = result;
88018   return jresult;
88019 }
88020
88021
88022 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
88023   unsigned int jresult ;
88024   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88025   unsigned int *arg2 = 0 ;
88026   unsigned int temp2 ;
88027   bool result;
88028
88029   arg1 = (std::vector< unsigned int > *)jarg1;
88030   temp2 = (unsigned int)jarg2;
88031   arg2 = &temp2;
88032   {
88033     try {
88034       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
88035     } catch (std::out_of_range& e) {
88036       {
88037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88038       };
88039     } catch (std::exception& e) {
88040       {
88041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88042       };
88043     } catch (Dali::DaliException e) {
88044       {
88045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88046       };
88047     } catch (...) {
88048       {
88049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88050       };
88051     }
88052   }
88053
88054   jresult = result;
88055   return jresult;
88056 }
88057
88058
88059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
88060   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88061
88062   arg1 = (std::vector< unsigned int > *)jarg1;
88063   {
88064     try {
88065       delete arg1;
88066     } catch (std::out_of_range& e) {
88067       {
88068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88069       };
88070     } catch (std::exception& e) {
88071       {
88072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88073       };
88074     } catch (Dali::DaliException e) {
88075       {
88076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88077       };
88078     } catch (...) {
88079       {
88080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88081       };
88082     }
88083   }
88084
88085 }
88086
88087
88088 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
88089   void * jresult ;
88090   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88091
88092   {
88093     try {
88094       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
88095     } catch (std::out_of_range& e) {
88096       {
88097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88098       };
88099     } catch (std::exception& e) {
88100       {
88101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88102       };
88103     } catch (Dali::DaliException e) {
88104       {
88105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88106       };
88107     } catch (...) {
88108       {
88109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88110       };
88111     }
88112   }
88113
88114   jresult = (void *)result;
88115   return jresult;
88116 }
88117
88118
88119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
88120   void * jresult ;
88121   unsigned int arg1 ;
88122   Dali::Actor arg2 ;
88123   Dali::Actor *argp2 ;
88124   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88125
88126   arg1 = (unsigned int)jarg1;
88127   argp2 = (Dali::Actor *)jarg2;
88128   if (!argp2) {
88129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88130     return 0;
88131   }
88132   arg2 = *argp2;
88133   {
88134     try {
88135       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
88136     } catch (std::out_of_range& e) {
88137       {
88138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88139       };
88140     } catch (std::exception& e) {
88141       {
88142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88143       };
88144     } catch (Dali::DaliException e) {
88145       {
88146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88147       };
88148     } catch (...) {
88149       {
88150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88151       };
88152     }
88153   }
88154
88155   jresult = (void *)result;
88156   return jresult;
88157 }
88158
88159
88160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
88161   void * jresult ;
88162   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88163   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88164
88165   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88166   if (!arg1) {
88167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88168     return 0;
88169   }
88170   {
88171     try {
88172       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
88173     } catch (std::out_of_range& e) {
88174       {
88175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88176       };
88177     } catch (std::exception& e) {
88178       {
88179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88180       };
88181     } catch (Dali::DaliException e) {
88182       {
88183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88184       };
88185     } catch (...) {
88186       {
88187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88188       };
88189     }
88190   }
88191
88192   jresult = (void *)result;
88193   return jresult;
88194 }
88195
88196
88197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
88198   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88199   unsigned int arg2 ;
88200
88201   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88202   arg2 = (unsigned int)jarg2;
88203   if (arg1) (arg1)->first = arg2;
88204 }
88205
88206
88207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
88208   unsigned int jresult ;
88209   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88210   unsigned int result;
88211
88212   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88213   result = (unsigned int) ((arg1)->first);
88214   jresult = result;
88215   return jresult;
88216 }
88217
88218
88219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
88220   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88221   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
88222
88223   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88224   arg2 = (Dali::Actor *)jarg2;
88225   if (arg1) (arg1)->second = *arg2;
88226 }
88227
88228
88229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
88230   void * jresult ;
88231   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88232   Dali::Actor *result = 0 ;
88233
88234   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88235   result = (Dali::Actor *)& ((arg1)->second);
88236   jresult = (void *)result;
88237   return jresult;
88238 }
88239
88240
88241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
88242   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88243
88244   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88245   {
88246     try {
88247       delete arg1;
88248     } catch (std::out_of_range& e) {
88249       {
88250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88251       };
88252     } catch (std::exception& e) {
88253       {
88254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88255       };
88256     } catch (Dali::DaliException e) {
88257       {
88258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88259       };
88260     } catch (...) {
88261       {
88262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88263       };
88264     }
88265   }
88266
88267 }
88268
88269
88270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
88271   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88272
88273   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88274   {
88275     try {
88276       (arg1)->clear();
88277     } catch (std::out_of_range& e) {
88278       {
88279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88280       };
88281     } catch (std::exception& e) {
88282       {
88283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88284       };
88285     } catch (Dali::DaliException e) {
88286       {
88287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88288       };
88289     } catch (...) {
88290       {
88291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88292       };
88293     }
88294   }
88295
88296 }
88297
88298
88299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
88300   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88301   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
88302
88303   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88304   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
88305   if (!arg2) {
88306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88307     return ;
88308   }
88309   {
88310     try {
88311       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
88312     } catch (std::out_of_range& e) {
88313       {
88314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88315       };
88316     } catch (std::exception& e) {
88317       {
88318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88319       };
88320     } catch (Dali::DaliException e) {
88321       {
88322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88323       };
88324     } catch (...) {
88325       {
88326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88327       };
88328     }
88329   }
88330
88331 }
88332
88333
88334 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
88335   unsigned long jresult ;
88336   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88337   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88338
88339   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88340   {
88341     try {
88342       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
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 = (unsigned long)result;
88363   return jresult;
88364 }
88365
88366
88367 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
88368   unsigned long jresult ;
88369   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88370   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88371
88372   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88373   {
88374     try {
88375       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
88376     } catch (std::out_of_range& e) {
88377       {
88378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88379       };
88380     } catch (std::exception& e) {
88381       {
88382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88383       };
88384     } catch (Dali::DaliException e) {
88385       {
88386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88387       };
88388     } catch (...) {
88389       {
88390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88391       };
88392     }
88393   }
88394
88395   jresult = (unsigned long)result;
88396   return jresult;
88397 }
88398
88399
88400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
88401   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88402   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
88403
88404   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88405   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
88406   {
88407     try {
88408       (arg1)->reserve(arg2);
88409     } catch (std::out_of_range& e) {
88410       {
88411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88412       };
88413     } catch (std::exception& e) {
88414       {
88415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88416       };
88417     } catch (Dali::DaliException e) {
88418       {
88419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88420       };
88421     } catch (...) {
88422       {
88423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88424       };
88425     }
88426   }
88427
88428 }
88429
88430
88431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
88432   void * jresult ;
88433   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88434
88435   {
88436     try {
88437       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
88438     } catch (std::out_of_range& e) {
88439       {
88440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88441       };
88442     } catch (std::exception& e) {
88443       {
88444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88445       };
88446     } catch (Dali::DaliException e) {
88447       {
88448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88449       };
88450     } catch (...) {
88451       {
88452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88453       };
88454     }
88455   }
88456
88457   jresult = (void *)result;
88458   return jresult;
88459 }
88460
88461
88462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
88463   void * jresult ;
88464   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
88465   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88466
88467   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88468   if (!arg1) {
88469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88470     return 0;
88471   }
88472   {
88473     try {
88474       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);
88475     } catch (std::out_of_range& e) {
88476       {
88477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88478       };
88479     } catch (std::exception& e) {
88480       {
88481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88482       };
88483     } catch (Dali::DaliException e) {
88484       {
88485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88486       };
88487     } catch (...) {
88488       {
88489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88490       };
88491     }
88492   }
88493
88494   jresult = (void *)result;
88495   return jresult;
88496 }
88497
88498
88499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
88500   void * jresult ;
88501   int arg1 ;
88502   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88503
88504   arg1 = (int)jarg1;
88505   {
88506     try {
88507       try {
88508         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);
88509       }
88510       catch(std::out_of_range &_e) {
88511         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88512         return 0;
88513       }
88514
88515     } catch (std::out_of_range& e) {
88516       {
88517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88518       };
88519     } catch (std::exception& e) {
88520       {
88521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88522       };
88523     } catch (Dali::DaliException e) {
88524       {
88525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88526       };
88527     } catch (...) {
88528       {
88529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88530       };
88531     }
88532   }
88533
88534   jresult = (void *)result;
88535   return jresult;
88536 }
88537
88538
88539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
88540   void * jresult ;
88541   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88542   int arg2 ;
88543   std::pair< unsigned int,Dali::Actor > result;
88544
88545   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88546   arg2 = (int)jarg2;
88547   {
88548     try {
88549       try {
88550         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
88551       }
88552       catch(std::out_of_range &_e) {
88553         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88554         return 0;
88555       }
88556
88557     } catch (std::out_of_range& e) {
88558       {
88559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88560       };
88561     } catch (std::exception& e) {
88562       {
88563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88564       };
88565     } catch (Dali::DaliException e) {
88566       {
88567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88568       };
88569     } catch (...) {
88570       {
88571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88572       };
88573     }
88574   }
88575
88576   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
88577   return jresult;
88578 }
88579
88580
88581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
88582   void * jresult ;
88583   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88584   int arg2 ;
88585   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88586
88587   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88588   arg2 = (int)jarg2;
88589   {
88590     try {
88591       try {
88592         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
88593       }
88594       catch(std::out_of_range &_e) {
88595         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88596         return 0;
88597       }
88598
88599     } catch (std::out_of_range& e) {
88600       {
88601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88602       };
88603     } catch (std::exception& e) {
88604       {
88605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88606       };
88607     } catch (Dali::DaliException e) {
88608       {
88609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88610       };
88611     } catch (...) {
88612       {
88613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88614       };
88615     }
88616   }
88617
88618   jresult = (void *)result;
88619   return jresult;
88620 }
88621
88622
88623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88624   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88625   int arg2 ;
88626   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88627
88628   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88629   arg2 = (int)jarg2;
88630   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88631   if (!arg3) {
88632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88633     return ;
88634   }
88635   {
88636     try {
88637       try {
88638         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);
88639       }
88640       catch(std::out_of_range &_e) {
88641         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88642         return ;
88643       }
88644
88645     } catch (std::out_of_range& e) {
88646       {
88647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88648       };
88649     } catch (std::exception& e) {
88650       {
88651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88652       };
88653     } catch (Dali::DaliException e) {
88654       {
88655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88656       };
88657     } catch (...) {
88658       {
88659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88660       };
88661     }
88662   }
88663
88664 }
88665
88666
88667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
88668   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88669   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
88670
88671   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88672   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
88673   if (!arg2) {
88674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88675     return ;
88676   }
88677   {
88678     try {
88679       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);
88680     } catch (std::out_of_range& e) {
88681       {
88682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88683       };
88684     } catch (std::exception& e) {
88685       {
88686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88687       };
88688     } catch (Dali::DaliException e) {
88689       {
88690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88691       };
88692     } catch (...) {
88693       {
88694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88695       };
88696     }
88697   }
88698
88699 }
88700
88701
88702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88703   void * jresult ;
88704   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88705   int arg2 ;
88706   int arg3 ;
88707   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
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         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);
88716       }
88717       catch(std::out_of_range &_e) {
88718         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88719         return 0;
88720       }
88721       catch(std::invalid_argument &_e) {
88722         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88723         return 0;
88724       }
88725
88726     } catch (std::out_of_range& e) {
88727       {
88728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88729       };
88730     } catch (std::exception& e) {
88731       {
88732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88733       };
88734     } catch (Dali::DaliException e) {
88735       {
88736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88737       };
88738     } catch (...) {
88739       {
88740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88741       };
88742     }
88743   }
88744
88745   jresult = (void *)result;
88746   return jresult;
88747 }
88748
88749
88750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88751   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88752   int arg2 ;
88753   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88754
88755   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88756   arg2 = (int)jarg2;
88757   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88758   if (!arg3) {
88759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88760     return ;
88761   }
88762   {
88763     try {
88764       try {
88765         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);
88766       }
88767       catch(std::out_of_range &_e) {
88768         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88769         return ;
88770       }
88771
88772     } catch (std::out_of_range& e) {
88773       {
88774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88775       };
88776     } catch (std::exception& e) {
88777       {
88778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88779       };
88780     } catch (Dali::DaliException e) {
88781       {
88782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88783       };
88784     } catch (...) {
88785       {
88786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88787       };
88788     }
88789   }
88790
88791 }
88792
88793
88794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88795   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88796   int arg2 ;
88797   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88798
88799   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88800   arg2 = (int)jarg2;
88801   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88802   if (!arg3) {
88803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88804     return ;
88805   }
88806   {
88807     try {
88808       try {
88809         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);
88810       }
88811       catch(std::out_of_range &_e) {
88812         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88813         return ;
88814       }
88815
88816     } catch (std::out_of_range& e) {
88817       {
88818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88819       };
88820     } catch (std::exception& e) {
88821       {
88822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88823       };
88824     } catch (Dali::DaliException e) {
88825       {
88826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88827       };
88828     } catch (...) {
88829       {
88830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88831       };
88832     }
88833   }
88834
88835 }
88836
88837
88838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
88839   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88840   int arg2 ;
88841
88842   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88843   arg2 = (int)jarg2;
88844   {
88845     try {
88846       try {
88847         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
88848       }
88849       catch(std::out_of_range &_e) {
88850         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88851         return ;
88852       }
88853
88854     } catch (std::out_of_range& e) {
88855       {
88856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88857       };
88858     } catch (std::exception& e) {
88859       {
88860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88861       };
88862     } catch (Dali::DaliException e) {
88863       {
88864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88865       };
88866     } catch (...) {
88867       {
88868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88869       };
88870     }
88871   }
88872
88873 }
88874
88875
88876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88877   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88878   int arg2 ;
88879   int arg3 ;
88880
88881   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88882   arg2 = (int)jarg2;
88883   arg3 = (int)jarg3;
88884   {
88885     try {
88886       try {
88887         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
88888       }
88889       catch(std::out_of_range &_e) {
88890         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88891         return ;
88892       }
88893       catch(std::invalid_argument &_e) {
88894         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88895         return ;
88896       }
88897
88898     } catch (std::out_of_range& e) {
88899       {
88900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88901       };
88902     } catch (std::exception& e) {
88903       {
88904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88905       };
88906     } catch (Dali::DaliException e) {
88907       {
88908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88909       };
88910     } catch (...) {
88911       {
88912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88913       };
88914     }
88915   }
88916
88917 }
88918
88919
88920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
88921   void * jresult ;
88922   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88923   int arg2 ;
88924   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88925
88926   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88927   if (!arg1) {
88928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88929     return 0;
88930   }
88931   arg2 = (int)jarg2;
88932   {
88933     try {
88934       try {
88935         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);
88936       }
88937       catch(std::out_of_range &_e) {
88938         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88939         return 0;
88940       }
88941
88942     } catch (std::out_of_range& e) {
88943       {
88944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88945       };
88946     } catch (std::exception& e) {
88947       {
88948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88949       };
88950     } catch (Dali::DaliException e) {
88951       {
88952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88953       };
88954     } catch (...) {
88955       {
88956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88957       };
88958     }
88959   }
88960
88961   jresult = (void *)result;
88962   return jresult;
88963 }
88964
88965
88966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
88967   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88968
88969   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88970   {
88971     try {
88972       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
88973     } catch (std::out_of_range& e) {
88974       {
88975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88976       };
88977     } catch (std::exception& e) {
88978       {
88979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88980       };
88981     } catch (Dali::DaliException e) {
88982       {
88983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88984       };
88985     } catch (...) {
88986       {
88987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88988       };
88989     }
88990   }
88991
88992 }
88993
88994
88995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88996   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88997   int arg2 ;
88998   int arg3 ;
88999
89000   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89001   arg2 = (int)jarg2;
89002   arg3 = (int)jarg3;
89003   {
89004     try {
89005       try {
89006         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89007       }
89008       catch(std::out_of_range &_e) {
89009         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89010         return ;
89011       }
89012       catch(std::invalid_argument &_e) {
89013         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89014         return ;
89015       }
89016
89017     } catch (std::out_of_range& e) {
89018       {
89019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89020       };
89021     } catch (std::exception& e) {
89022       {
89023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89024       };
89025     } catch (Dali::DaliException e) {
89026       {
89027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89028       };
89029     } catch (...) {
89030       {
89031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89032       };
89033     }
89034   }
89035
89036 }
89037
89038
89039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89040   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89041   int arg2 ;
89042   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
89043
89044   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89045   arg2 = (int)jarg2;
89046   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
89047   if (!arg3) {
89048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89049     return ;
89050   }
89051   {
89052     try {
89053       try {
89054         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);
89055       }
89056       catch(std::out_of_range &_e) {
89057         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89058         return ;
89059       }
89060
89061     } catch (std::out_of_range& e) {
89062       {
89063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89064       };
89065     } catch (std::exception& e) {
89066       {
89067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89068       };
89069     } catch (Dali::DaliException e) {
89070       {
89071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89072       };
89073     } catch (...) {
89074       {
89075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89076       };
89077     }
89078   }
89079
89080 }
89081
89082
89083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
89084   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89085
89086   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89087   {
89088     try {
89089       delete arg1;
89090     } catch (std::out_of_range& e) {
89091       {
89092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89093       };
89094     } catch (std::exception& e) {
89095       {
89096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89097       };
89098     } catch (Dali::DaliException e) {
89099       {
89100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89101       };
89102     } catch (...) {
89103       {
89104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89105       };
89106     }
89107   }
89108
89109 }
89110
89111
89112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
89113   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89114
89115   arg1 = (std::vector< Dali::Actor > *)jarg1;
89116   {
89117     try {
89118       (arg1)->clear();
89119     } catch (std::out_of_range& e) {
89120       {
89121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89122       };
89123     } catch (std::exception& e) {
89124       {
89125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89126       };
89127     } catch (Dali::DaliException e) {
89128       {
89129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89130       };
89131     } catch (...) {
89132       {
89133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89134       };
89135     }
89136   }
89137
89138 }
89139
89140
89141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
89142   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89143   Dali::Actor *arg2 = 0 ;
89144
89145   arg1 = (std::vector< Dali::Actor > *)jarg1;
89146   arg2 = (Dali::Actor *)jarg2;
89147   if (!arg2) {
89148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89149     return ;
89150   }
89151   {
89152     try {
89153       (arg1)->push_back((Dali::Actor const &)*arg2);
89154     } catch (std::out_of_range& e) {
89155       {
89156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89157       };
89158     } catch (std::exception& e) {
89159       {
89160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89161       };
89162     } catch (Dali::DaliException e) {
89163       {
89164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89165       };
89166     } catch (...) {
89167       {
89168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89169       };
89170     }
89171   }
89172
89173 }
89174
89175
89176 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
89177   unsigned long jresult ;
89178   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89179   std::vector< Dali::Actor >::size_type result;
89180
89181   arg1 = (std::vector< Dali::Actor > *)jarg1;
89182   {
89183     try {
89184       result = ((std::vector< Dali::Actor > const *)arg1)->size();
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 = (unsigned long)result;
89205   return jresult;
89206 }
89207
89208
89209 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
89210   unsigned long jresult ;
89211   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89212   std::vector< Dali::Actor >::size_type result;
89213
89214   arg1 = (std::vector< Dali::Actor > *)jarg1;
89215   {
89216     try {
89217       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
89218     } catch (std::out_of_range& e) {
89219       {
89220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89221       };
89222     } catch (std::exception& e) {
89223       {
89224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89225       };
89226     } catch (Dali::DaliException e) {
89227       {
89228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89229       };
89230     } catch (...) {
89231       {
89232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89233       };
89234     }
89235   }
89236
89237   jresult = (unsigned long)result;
89238   return jresult;
89239 }
89240
89241
89242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
89243   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89244   std::vector< Dali::Actor >::size_type arg2 ;
89245
89246   arg1 = (std::vector< Dali::Actor > *)jarg1;
89247   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
89248   {
89249     try {
89250       (arg1)->reserve(arg2);
89251     } catch (std::out_of_range& e) {
89252       {
89253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89254       };
89255     } catch (std::exception& e) {
89256       {
89257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89258       };
89259     } catch (Dali::DaliException e) {
89260       {
89261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89262       };
89263     } catch (...) {
89264       {
89265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89266       };
89267     }
89268   }
89269
89270 }
89271
89272
89273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
89274   void * jresult ;
89275   std::vector< Dali::Actor > *result = 0 ;
89276
89277   {
89278     try {
89279       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
89280     } catch (std::out_of_range& e) {
89281       {
89282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89283       };
89284     } catch (std::exception& e) {
89285       {
89286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89287       };
89288     } catch (Dali::DaliException e) {
89289       {
89290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89291       };
89292     } catch (...) {
89293       {
89294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89295       };
89296     }
89297   }
89298
89299   jresult = (void *)result;
89300   return jresult;
89301 }
89302
89303
89304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
89305   void * jresult ;
89306   std::vector< Dali::Actor > *arg1 = 0 ;
89307   std::vector< Dali::Actor > *result = 0 ;
89308
89309   arg1 = (std::vector< Dali::Actor > *)jarg1;
89310   if (!arg1) {
89311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89312     return 0;
89313   }
89314   {
89315     try {
89316       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
89317     } catch (std::out_of_range& e) {
89318       {
89319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89320       };
89321     } catch (std::exception& e) {
89322       {
89323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89324       };
89325     } catch (Dali::DaliException e) {
89326       {
89327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89328       };
89329     } catch (...) {
89330       {
89331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89332       };
89333     }
89334   }
89335
89336   jresult = (void *)result;
89337   return jresult;
89338 }
89339
89340
89341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
89342   void * jresult ;
89343   int arg1 ;
89344   std::vector< Dali::Actor > *result = 0 ;
89345
89346   arg1 = (int)jarg1;
89347   {
89348     try {
89349       try {
89350         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
89351       }
89352       catch(std::out_of_range &_e) {
89353         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89354         return 0;
89355       }
89356
89357     } catch (std::out_of_range& e) {
89358       {
89359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89360       };
89361     } catch (std::exception& e) {
89362       {
89363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89364       };
89365     } catch (Dali::DaliException e) {
89366       {
89367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89368       };
89369     } catch (...) {
89370       {
89371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89372       };
89373     }
89374   }
89375
89376   jresult = (void *)result;
89377   return jresult;
89378 }
89379
89380
89381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
89382   void * jresult ;
89383   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89384   int arg2 ;
89385   Dali::Actor result;
89386
89387   arg1 = (std::vector< Dali::Actor > *)jarg1;
89388   arg2 = (int)jarg2;
89389   {
89390     try {
89391       try {
89392         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
89393       }
89394       catch(std::out_of_range &_e) {
89395         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89396         return 0;
89397       }
89398
89399     } catch (std::out_of_range& e) {
89400       {
89401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89402       };
89403     } catch (std::exception& e) {
89404       {
89405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89406       };
89407     } catch (Dali::DaliException e) {
89408       {
89409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89410       };
89411     } catch (...) {
89412       {
89413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89414       };
89415     }
89416   }
89417
89418   jresult = new Dali::Actor((const Dali::Actor &)result);
89419   return jresult;
89420 }
89421
89422
89423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
89424   void * jresult ;
89425   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89426   int arg2 ;
89427   Dali::Actor *result = 0 ;
89428
89429   arg1 = (std::vector< Dali::Actor > *)jarg1;
89430   arg2 = (int)jarg2;
89431   {
89432     try {
89433       try {
89434         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
89435       }
89436       catch(std::out_of_range &_e) {
89437         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89438         return 0;
89439       }
89440
89441     } catch (std::out_of_range& e) {
89442       {
89443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89444       };
89445     } catch (std::exception& e) {
89446       {
89447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89448       };
89449     } catch (Dali::DaliException e) {
89450       {
89451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89452       };
89453     } catch (...) {
89454       {
89455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89456       };
89457     }
89458   }
89459
89460   jresult = (void *)result;
89461   return jresult;
89462 }
89463
89464
89465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
89466   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89467   int arg2 ;
89468   Dali::Actor *arg3 = 0 ;
89469
89470   arg1 = (std::vector< Dali::Actor > *)jarg1;
89471   arg2 = (int)jarg2;
89472   arg3 = (Dali::Actor *)jarg3;
89473   if (!arg3) {
89474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89475     return ;
89476   }
89477   {
89478     try {
89479       try {
89480         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
89481       }
89482       catch(std::out_of_range &_e) {
89483         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89484         return ;
89485       }
89486
89487     } catch (std::out_of_range& e) {
89488       {
89489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89490       };
89491     } catch (std::exception& e) {
89492       {
89493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89494       };
89495     } catch (Dali::DaliException e) {
89496       {
89497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89498       };
89499     } catch (...) {
89500       {
89501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89502       };
89503     }
89504   }
89505
89506 }
89507
89508
89509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
89510   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89511   std::vector< Dali::Actor > *arg2 = 0 ;
89512
89513   arg1 = (std::vector< Dali::Actor > *)jarg1;
89514   arg2 = (std::vector< Dali::Actor > *)jarg2;
89515   if (!arg2) {
89516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89517     return ;
89518   }
89519   {
89520     try {
89521       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
89522     } catch (std::out_of_range& e) {
89523       {
89524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89525       };
89526     } catch (std::exception& e) {
89527       {
89528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89529       };
89530     } catch (Dali::DaliException e) {
89531       {
89532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89533       };
89534     } catch (...) {
89535       {
89536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89537       };
89538     }
89539   }
89540
89541 }
89542
89543
89544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
89545   void * jresult ;
89546   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89547   int arg2 ;
89548   int arg3 ;
89549   std::vector< Dali::Actor > *result = 0 ;
89550
89551   arg1 = (std::vector< Dali::Actor > *)jarg1;
89552   arg2 = (int)jarg2;
89553   arg3 = (int)jarg3;
89554   {
89555     try {
89556       try {
89557         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
89558       }
89559       catch(std::out_of_range &_e) {
89560         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89561         return 0;
89562       }
89563       catch(std::invalid_argument &_e) {
89564         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89565         return 0;
89566       }
89567
89568     } catch (std::out_of_range& e) {
89569       {
89570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89571       };
89572     } catch (std::exception& e) {
89573       {
89574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89575       };
89576     } catch (Dali::DaliException e) {
89577       {
89578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89579       };
89580     } catch (...) {
89581       {
89582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89583       };
89584     }
89585   }
89586
89587   jresult = (void *)result;
89588   return jresult;
89589 }
89590
89591
89592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
89593   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89594   int arg2 ;
89595   Dali::Actor *arg3 = 0 ;
89596
89597   arg1 = (std::vector< Dali::Actor > *)jarg1;
89598   arg2 = (int)jarg2;
89599   arg3 = (Dali::Actor *)jarg3;
89600   if (!arg3) {
89601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89602     return ;
89603   }
89604   {
89605     try {
89606       try {
89607         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
89608       }
89609       catch(std::out_of_range &_e) {
89610         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89611         return ;
89612       }
89613
89614     } catch (std::out_of_range& e) {
89615       {
89616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89617       };
89618     } catch (std::exception& e) {
89619       {
89620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89621       };
89622     } catch (Dali::DaliException e) {
89623       {
89624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89625       };
89626     } catch (...) {
89627       {
89628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89629       };
89630     }
89631   }
89632
89633 }
89634
89635
89636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89637   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89638   int arg2 ;
89639   std::vector< Dali::Actor > *arg3 = 0 ;
89640
89641   arg1 = (std::vector< Dali::Actor > *)jarg1;
89642   arg2 = (int)jarg2;
89643   arg3 = (std::vector< Dali::Actor > *)jarg3;
89644   if (!arg3) {
89645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89646     return ;
89647   }
89648   {
89649     try {
89650       try {
89651         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89652       }
89653       catch(std::out_of_range &_e) {
89654         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89655         return ;
89656       }
89657
89658     } catch (std::out_of_range& e) {
89659       {
89660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89661       };
89662     } catch (std::exception& e) {
89663       {
89664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89665       };
89666     } catch (Dali::DaliException e) {
89667       {
89668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89669       };
89670     } catch (...) {
89671       {
89672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89673       };
89674     }
89675   }
89676
89677 }
89678
89679
89680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
89681   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89682   int arg2 ;
89683
89684   arg1 = (std::vector< Dali::Actor > *)jarg1;
89685   arg2 = (int)jarg2;
89686   {
89687     try {
89688       try {
89689         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
89690       }
89691       catch(std::out_of_range &_e) {
89692         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89693         return ;
89694       }
89695
89696     } catch (std::out_of_range& e) {
89697       {
89698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89699       };
89700     } catch (std::exception& e) {
89701       {
89702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89703       };
89704     } catch (Dali::DaliException e) {
89705       {
89706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89707       };
89708     } catch (...) {
89709       {
89710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89711       };
89712     }
89713   }
89714
89715 }
89716
89717
89718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89719   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89720   int arg2 ;
89721   int arg3 ;
89722
89723   arg1 = (std::vector< Dali::Actor > *)jarg1;
89724   arg2 = (int)jarg2;
89725   arg3 = (int)jarg3;
89726   {
89727     try {
89728       try {
89729         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
89730       }
89731       catch(std::out_of_range &_e) {
89732         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89733         return ;
89734       }
89735       catch(std::invalid_argument &_e) {
89736         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89737         return ;
89738       }
89739
89740     } catch (std::out_of_range& e) {
89741       {
89742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89743       };
89744     } catch (std::exception& e) {
89745       {
89746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89747       };
89748     } catch (Dali::DaliException e) {
89749       {
89750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89751       };
89752     } catch (...) {
89753       {
89754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89755       };
89756     }
89757   }
89758
89759 }
89760
89761
89762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
89763   void * jresult ;
89764   Dali::Actor *arg1 = 0 ;
89765   int arg2 ;
89766   std::vector< Dali::Actor > *result = 0 ;
89767
89768   arg1 = (Dali::Actor *)jarg1;
89769   if (!arg1) {
89770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89771     return 0;
89772   }
89773   arg2 = (int)jarg2;
89774   {
89775     try {
89776       try {
89777         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
89778       }
89779       catch(std::out_of_range &_e) {
89780         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89781         return 0;
89782       }
89783
89784     } catch (std::out_of_range& e) {
89785       {
89786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89787       };
89788     } catch (std::exception& e) {
89789       {
89790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89791       };
89792     } catch (Dali::DaliException e) {
89793       {
89794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89795       };
89796     } catch (...) {
89797       {
89798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89799       };
89800     }
89801   }
89802
89803   jresult = (void *)result;
89804   return jresult;
89805 }
89806
89807
89808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
89809   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89810
89811   arg1 = (std::vector< Dali::Actor > *)jarg1;
89812   {
89813     try {
89814       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
89815     } catch (std::out_of_range& e) {
89816       {
89817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89818       };
89819     } catch (std::exception& e) {
89820       {
89821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89822       };
89823     } catch (Dali::DaliException e) {
89824       {
89825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89826       };
89827     } catch (...) {
89828       {
89829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89830       };
89831     }
89832   }
89833
89834 }
89835
89836
89837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89838   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89839   int arg2 ;
89840   int arg3 ;
89841
89842   arg1 = (std::vector< Dali::Actor > *)jarg1;
89843   arg2 = (int)jarg2;
89844   arg3 = (int)jarg3;
89845   {
89846     try {
89847       try {
89848         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89849       }
89850       catch(std::out_of_range &_e) {
89851         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89852         return ;
89853       }
89854       catch(std::invalid_argument &_e) {
89855         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89856         return ;
89857       }
89858
89859     } catch (std::out_of_range& e) {
89860       {
89861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89862       };
89863     } catch (std::exception& e) {
89864       {
89865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89866       };
89867     } catch (Dali::DaliException e) {
89868       {
89869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89870       };
89871     } catch (...) {
89872       {
89873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89874       };
89875     }
89876   }
89877
89878 }
89879
89880
89881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89882   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89883   int arg2 ;
89884   std::vector< Dali::Actor > *arg3 = 0 ;
89885
89886   arg1 = (std::vector< Dali::Actor > *)jarg1;
89887   arg2 = (int)jarg2;
89888   arg3 = (std::vector< Dali::Actor > *)jarg3;
89889   if (!arg3) {
89890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89891     return ;
89892   }
89893   {
89894     try {
89895       try {
89896         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89897       }
89898       catch(std::out_of_range &_e) {
89899         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89900         return ;
89901       }
89902
89903     } catch (std::out_of_range& e) {
89904       {
89905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89906       };
89907     } catch (std::exception& e) {
89908       {
89909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89910       };
89911     } catch (Dali::DaliException e) {
89912       {
89913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89914       };
89915     } catch (...) {
89916       {
89917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89918       };
89919     }
89920   }
89921
89922 }
89923
89924
89925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
89926   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89927
89928   arg1 = (std::vector< Dali::Actor > *)jarg1;
89929   {
89930     try {
89931       delete arg1;
89932     } catch (std::out_of_range& e) {
89933       {
89934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89935       };
89936     } catch (std::exception& e) {
89937       {
89938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89939       };
89940     } catch (Dali::DaliException e) {
89941       {
89942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89943       };
89944     } catch (...) {
89945       {
89946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89947       };
89948     }
89949   }
89950
89951 }
89952
89953
89954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
89955   unsigned int jresult ;
89956   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89957   bool result;
89958
89959   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89960   {
89961     try {
89962       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89963     } catch (std::out_of_range& e) {
89964       {
89965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89966       };
89967     } catch (std::exception& e) {
89968       {
89969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89970       };
89971     } catch (Dali::DaliException e) {
89972       {
89973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89974       };
89975     } catch (...) {
89976       {
89977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89978       };
89979     }
89980   }
89981
89982   jresult = result;
89983   return jresult;
89984 }
89985
89986
89987 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
89988   unsigned long jresult ;
89989   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89990   std::size_t result;
89991
89992   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89993   {
89994     try {
89995       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89996     } catch (std::out_of_range& e) {
89997       {
89998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89999       };
90000     } catch (std::exception& e) {
90001       {
90002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90003       };
90004     } catch (Dali::DaliException e) {
90005       {
90006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90007       };
90008     } catch (...) {
90009       {
90010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90011       };
90012     }
90013   }
90014
90015   jresult = (unsigned long)result;
90016   return jresult;
90017 }
90018
90019
90020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
90021   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90022   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90023
90024   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90025   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90026   {
90027     try {
90028       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
90029     } catch (std::out_of_range& e) {
90030       {
90031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90032       };
90033     } catch (std::exception& e) {
90034       {
90035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90036       };
90037     } catch (Dali::DaliException e) {
90038       {
90039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90040       };
90041     } catch (...) {
90042       {
90043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90044       };
90045     }
90046   }
90047
90048 }
90049
90050
90051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
90052   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90053   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90054
90055   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90056   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90057   {
90058     try {
90059       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
90060     } catch (std::out_of_range& e) {
90061       {
90062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90063       };
90064     } catch (std::exception& e) {
90065       {
90066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90067       };
90068     } catch (Dali::DaliException e) {
90069       {
90070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90071       };
90072     } catch (...) {
90073       {
90074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90075       };
90076     }
90077   }
90078
90079 }
90080
90081
90082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
90083   unsigned int jresult ;
90084   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90085   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
90086   bool result;
90087
90088   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90089   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
90090   if (!arg2) {
90091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
90092     return 0;
90093   }
90094   {
90095     try {
90096       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
90097     } catch (std::out_of_range& e) {
90098       {
90099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90100       };
90101     } catch (std::exception& e) {
90102       {
90103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90104       };
90105     } catch (Dali::DaliException e) {
90106       {
90107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90108       };
90109     } catch (...) {
90110       {
90111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90112       };
90113     }
90114   }
90115
90116   jresult = result;
90117   return jresult;
90118 }
90119
90120
90121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
90122   void * jresult ;
90123   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
90124
90125   {
90126     try {
90127       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
90128     } catch (std::out_of_range& e) {
90129       {
90130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90131       };
90132     } catch (std::exception& e) {
90133       {
90134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90135       };
90136     } catch (Dali::DaliException e) {
90137       {
90138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90139       };
90140     } catch (...) {
90141       {
90142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90143       };
90144     }
90145   }
90146
90147   jresult = (void *)result;
90148   return jresult;
90149 }
90150
90151
90152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
90153   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90154
90155   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90156   {
90157     try {
90158       delete arg1;
90159     } catch (std::out_of_range& e) {
90160       {
90161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90162       };
90163     } catch (std::exception& e) {
90164       {
90165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90166       };
90167     } catch (Dali::DaliException e) {
90168       {
90169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90170       };
90171     } catch (...) {
90172       {
90173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90174       };
90175     }
90176   }
90177
90178 }
90179
90180
90181 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
90182   unsigned int jresult ;
90183   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90184   bool result;
90185
90186   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90187   {
90188     try {
90189       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);
90190     } catch (std::out_of_range& e) {
90191       {
90192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90193       };
90194     } catch (std::exception& e) {
90195       {
90196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90197       };
90198     } catch (Dali::DaliException e) {
90199       {
90200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90201       };
90202     } catch (...) {
90203       {
90204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90205       };
90206     }
90207   }
90208
90209   jresult = result;
90210   return jresult;
90211 }
90212
90213
90214 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
90215   unsigned long jresult ;
90216   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90217   std::size_t result;
90218
90219   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90220   {
90221     try {
90222       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);
90223     } catch (std::out_of_range& e) {
90224       {
90225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90226       };
90227     } catch (std::exception& e) {
90228       {
90229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90230       };
90231     } catch (Dali::DaliException e) {
90232       {
90233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90234       };
90235     } catch (...) {
90236       {
90237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90238       };
90239     }
90240   }
90241
90242   jresult = (unsigned long)result;
90243   return jresult;
90244 }
90245
90246
90247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
90248   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90249   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90250
90251   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90252   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90253   {
90254     try {
90255       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
90256     } catch (std::out_of_range& e) {
90257       {
90258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90259       };
90260     } catch (std::exception& e) {
90261       {
90262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90263       };
90264     } catch (Dali::DaliException e) {
90265       {
90266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90267       };
90268     } catch (...) {
90269       {
90270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90271       };
90272     }
90273   }
90274
90275 }
90276
90277
90278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
90279   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90280   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90281
90282   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90283   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90284   {
90285     try {
90286       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
90287     } catch (std::out_of_range& e) {
90288       {
90289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90290       };
90291     } catch (std::exception& e) {
90292       {
90293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90294       };
90295     } catch (Dali::DaliException e) {
90296       {
90297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90298       };
90299     } catch (...) {
90300       {
90301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90302       };
90303     }
90304   }
90305
90306 }
90307
90308
90309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90310   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90311   Dali::Actor arg2 ;
90312   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
90313   Dali::Actor *argp2 ;
90314
90315   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90316   argp2 = (Dali::Actor *)jarg2;
90317   if (!argp2) {
90318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90319     return ;
90320   }
90321   arg2 = *argp2;
90322   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
90323   {
90324     try {
90325       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
90326     } catch (std::out_of_range& e) {
90327       {
90328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90329       };
90330     } catch (std::exception& e) {
90331       {
90332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90333       };
90334     } catch (Dali::DaliException e) {
90335       {
90336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90337       };
90338     } catch (...) {
90339       {
90340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90341       };
90342     }
90343   }
90344
90345 }
90346
90347
90348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
90349   void * jresult ;
90350   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
90351
90352   {
90353     try {
90354       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
90355     } catch (std::out_of_range& e) {
90356       {
90357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90358       };
90359     } catch (std::exception& e) {
90360       {
90361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90362       };
90363     } catch (Dali::DaliException e) {
90364       {
90365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90366       };
90367     } catch (...) {
90368       {
90369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90370       };
90371     }
90372   }
90373
90374   jresult = (void *)result;
90375   return jresult;
90376 }
90377
90378
90379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
90380   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90381
90382   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90383   {
90384     try {
90385       delete arg1;
90386     } catch (std::out_of_range& e) {
90387       {
90388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90389       };
90390     } catch (std::exception& e) {
90391       {
90392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90393       };
90394     } catch (Dali::DaliException e) {
90395       {
90396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90397       };
90398     } catch (...) {
90399       {
90400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90401       };
90402     }
90403   }
90404
90405 }
90406
90407
90408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
90409   unsigned int jresult ;
90410   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90411   bool result;
90412
90413   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90414   {
90415     try {
90416       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90417     } catch (std::out_of_range& e) {
90418       {
90419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90420       };
90421     } catch (std::exception& e) {
90422       {
90423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90424       };
90425     } catch (Dali::DaliException e) {
90426       {
90427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90428       };
90429     } catch (...) {
90430       {
90431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90432       };
90433     }
90434   }
90435
90436   jresult = result;
90437   return jresult;
90438 }
90439
90440
90441 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
90442   unsigned long jresult ;
90443   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90444   std::size_t result;
90445
90446   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90447   {
90448     try {
90449       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90450     } catch (std::out_of_range& e) {
90451       {
90452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90453       };
90454     } catch (std::exception& e) {
90455       {
90456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90457       };
90458     } catch (Dali::DaliException e) {
90459       {
90460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90461       };
90462     } catch (...) {
90463       {
90464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90465       };
90466     }
90467   }
90468
90469   jresult = (unsigned long)result;
90470   return jresult;
90471 }
90472
90473
90474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
90475   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90476   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90477
90478   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90479   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90480   {
90481     try {
90482       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
90483     } catch (std::out_of_range& e) {
90484       {
90485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90486       };
90487     } catch (std::exception& e) {
90488       {
90489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90490       };
90491     } catch (Dali::DaliException e) {
90492       {
90493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90494       };
90495     } catch (...) {
90496       {
90497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90498       };
90499     }
90500   }
90501
90502 }
90503
90504
90505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90506   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90507   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90508
90509   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90510   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90511   {
90512     try {
90513       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
90514     } catch (std::out_of_range& e) {
90515       {
90516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90517       };
90518     } catch (std::exception& e) {
90519       {
90520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90521       };
90522     } catch (Dali::DaliException e) {
90523       {
90524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90525       };
90526     } catch (...) {
90527       {
90528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90529       };
90530     }
90531   }
90532
90533 }
90534
90535
90536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90537   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90538   Dali::Actor arg2 ;
90539   Dali::Actor arg3 ;
90540   Dali::Actor *argp2 ;
90541   Dali::Actor *argp3 ;
90542
90543   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90544   argp2 = (Dali::Actor *)jarg2;
90545   if (!argp2) {
90546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90547     return ;
90548   }
90549   arg2 = *argp2;
90550   argp3 = (Dali::Actor *)jarg3;
90551   if (!argp3) {
90552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90553     return ;
90554   }
90555   arg3 = *argp3;
90556   {
90557     try {
90558       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
90559     } catch (std::out_of_range& e) {
90560       {
90561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90562       };
90563     } catch (std::exception& e) {
90564       {
90565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90566       };
90567     } catch (Dali::DaliException e) {
90568       {
90569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90570       };
90571     } catch (...) {
90572       {
90573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90574       };
90575     }
90576   }
90577
90578 }
90579
90580
90581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
90582   void * jresult ;
90583   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
90584
90585   {
90586     try {
90587       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
90588     } catch (std::out_of_range& e) {
90589       {
90590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90591       };
90592     } catch (std::exception& e) {
90593       {
90594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90595       };
90596     } catch (Dali::DaliException e) {
90597       {
90598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90599       };
90600     } catch (...) {
90601       {
90602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90603       };
90604     }
90605   }
90606
90607   jresult = (void *)result;
90608   return jresult;
90609 }
90610
90611
90612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
90613   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90614
90615   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90616   {
90617     try {
90618       delete arg1;
90619     } catch (std::out_of_range& e) {
90620       {
90621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90622       };
90623     } catch (std::exception& e) {
90624       {
90625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90626       };
90627     } catch (Dali::DaliException e) {
90628       {
90629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90630       };
90631     } catch (...) {
90632       {
90633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90634       };
90635     }
90636   }
90637
90638 }
90639
90640
90641 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
90642   unsigned int jresult ;
90643   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90644   bool result;
90645
90646   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90647   {
90648     try {
90649       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90650     } catch (std::out_of_range& e) {
90651       {
90652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90653       };
90654     } catch (std::exception& e) {
90655       {
90656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90657       };
90658     } catch (Dali::DaliException e) {
90659       {
90660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90661       };
90662     } catch (...) {
90663       {
90664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90665       };
90666     }
90667   }
90668
90669   jresult = result;
90670   return jresult;
90671 }
90672
90673
90674 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
90675   unsigned long jresult ;
90676   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90677   std::size_t result;
90678
90679   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90680   {
90681     try {
90682       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90683     } catch (std::out_of_range& e) {
90684       {
90685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90686       };
90687     } catch (std::exception& e) {
90688       {
90689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90690       };
90691     } catch (Dali::DaliException e) {
90692       {
90693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90694       };
90695     } catch (...) {
90696       {
90697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90698       };
90699     }
90700   }
90701
90702   jresult = (unsigned long)result;
90703   return jresult;
90704 }
90705
90706
90707 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
90708   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90709   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90710
90711   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90712   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90713   {
90714     try {
90715       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
90716     } catch (std::out_of_range& e) {
90717       {
90718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90719       };
90720     } catch (std::exception& e) {
90721       {
90722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90723       };
90724     } catch (Dali::DaliException e) {
90725       {
90726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90727       };
90728     } catch (...) {
90729       {
90730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90731       };
90732     }
90733   }
90734
90735 }
90736
90737
90738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90739   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90740   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90741
90742   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90743   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90744   {
90745     try {
90746       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90747     } catch (std::out_of_range& e) {
90748       {
90749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90750       };
90751     } catch (std::exception& e) {
90752       {
90753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90754       };
90755     } catch (Dali::DaliException e) {
90756       {
90757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90758       };
90759     } catch (...) {
90760       {
90761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90762       };
90763     }
90764   }
90765
90766 }
90767
90768
90769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
90770   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90771   Dali::Actor arg2 ;
90772   bool arg3 ;
90773   Dali::Actor *argp2 ;
90774
90775   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90776   argp2 = (Dali::Actor *)jarg2;
90777   if (!argp2) {
90778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90779     return ;
90780   }
90781   arg2 = *argp2;
90782   arg3 = jarg3 ? true : false;
90783   {
90784     try {
90785       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
90786     } catch (std::out_of_range& e) {
90787       {
90788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90789       };
90790     } catch (std::exception& e) {
90791       {
90792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90793       };
90794     } catch (Dali::DaliException e) {
90795       {
90796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90797       };
90798     } catch (...) {
90799       {
90800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90801       };
90802     }
90803   }
90804
90805 }
90806
90807
90808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
90809   void * jresult ;
90810   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
90811
90812   {
90813     try {
90814       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
90815     } catch (std::out_of_range& e) {
90816       {
90817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90818       };
90819     } catch (std::exception& e) {
90820       {
90821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90822       };
90823     } catch (Dali::DaliException e) {
90824       {
90825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90826       };
90827     } catch (...) {
90828       {
90829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90830       };
90831     }
90832   }
90833
90834   jresult = (void *)result;
90835   return jresult;
90836 }
90837
90838
90839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
90840   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90841
90842   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90843   {
90844     try {
90845       delete arg1;
90846     } catch (std::out_of_range& e) {
90847       {
90848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90849       };
90850     } catch (std::exception& e) {
90851       {
90852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90853       };
90854     } catch (Dali::DaliException e) {
90855       {
90856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90857       };
90858     } catch (...) {
90859       {
90860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90861       };
90862     }
90863   }
90864
90865 }
90866
90867
90868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
90869   unsigned int jresult ;
90870   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90871   bool result;
90872
90873   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90874   {
90875     try {
90876       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);
90877     } catch (std::out_of_range& e) {
90878       {
90879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90880       };
90881     } catch (std::exception& e) {
90882       {
90883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90884       };
90885     } catch (Dali::DaliException e) {
90886       {
90887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90888       };
90889     } catch (...) {
90890       {
90891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90892       };
90893     }
90894   }
90895
90896   jresult = result;
90897   return jresult;
90898 }
90899
90900
90901 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
90902   unsigned long jresult ;
90903   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90904   std::size_t result;
90905
90906   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90907   {
90908     try {
90909       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);
90910     } catch (std::out_of_range& e) {
90911       {
90912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90913       };
90914     } catch (std::exception& e) {
90915       {
90916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90917       };
90918     } catch (Dali::DaliException e) {
90919       {
90920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90921       };
90922     } catch (...) {
90923       {
90924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90925       };
90926     }
90927   }
90928
90929   jresult = (unsigned long)result;
90930   return jresult;
90931 }
90932
90933
90934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
90935   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90936   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90937
90938   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90939   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90940   {
90941     try {
90942       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
90943     } catch (std::out_of_range& e) {
90944       {
90945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90946       };
90947     } catch (std::exception& e) {
90948       {
90949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90950       };
90951     } catch (Dali::DaliException e) {
90952       {
90953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90954       };
90955     } catch (...) {
90956       {
90957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90958       };
90959     }
90960   }
90961
90962 }
90963
90964
90965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90966   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90967   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90968
90969   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90970   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90971   {
90972     try {
90973       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
90974     } catch (std::out_of_range& e) {
90975       {
90976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90977       };
90978     } catch (std::exception& e) {
90979       {
90980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90981       };
90982     } catch (Dali::DaliException e) {
90983       {
90984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90985       };
90986     } catch (...) {
90987       {
90988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90989       };
90990     }
90991   }
90992
90993 }
90994
90995
90996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90997   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90998   Dali::Toolkit::StyleManager arg2 ;
90999   Dali::StyleChange::Type arg3 ;
91000   Dali::Toolkit::StyleManager *argp2 ;
91001
91002   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91003   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
91004   if (!argp2) {
91005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
91006     return ;
91007   }
91008   arg2 = *argp2;
91009   arg3 = (Dali::StyleChange::Type)jarg3;
91010   {
91011     try {
91012       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
91013     } catch (std::out_of_range& e) {
91014       {
91015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91016       };
91017     } catch (std::exception& e) {
91018       {
91019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91020       };
91021     } catch (Dali::DaliException e) {
91022       {
91023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91024       };
91025     } catch (...) {
91026       {
91027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91028       };
91029     }
91030   }
91031
91032 }
91033
91034
91035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
91036   void * jresult ;
91037   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
91038
91039   {
91040     try {
91041       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
91042     } catch (std::out_of_range& e) {
91043       {
91044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91045       };
91046     } catch (std::exception& e) {
91047       {
91048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91049       };
91050     } catch (Dali::DaliException e) {
91051       {
91052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91053       };
91054     } catch (...) {
91055       {
91056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91057       };
91058     }
91059   }
91060
91061   jresult = (void *)result;
91062   return jresult;
91063 }
91064
91065
91066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
91067   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91068
91069   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91070   {
91071     try {
91072       delete arg1;
91073     } catch (std::out_of_range& e) {
91074       {
91075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91076       };
91077     } catch (std::exception& e) {
91078       {
91079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91080       };
91081     } catch (Dali::DaliException e) {
91082       {
91083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91084       };
91085     } catch (...) {
91086       {
91087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91088       };
91089     }
91090   }
91091
91092 }
91093
91094
91095 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
91096   unsigned int jresult ;
91097   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91098   bool result;
91099
91100   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91101   {
91102     try {
91103       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91104     } catch (std::out_of_range& e) {
91105       {
91106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91107       };
91108     } catch (std::exception& e) {
91109       {
91110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91111       };
91112     } catch (Dali::DaliException e) {
91113       {
91114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91115       };
91116     } catch (...) {
91117       {
91118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91119       };
91120     }
91121   }
91122
91123   jresult = result;
91124   return jresult;
91125 }
91126
91127
91128 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
91129   unsigned long jresult ;
91130   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91131   std::size_t result;
91132
91133   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91134   {
91135     try {
91136       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91137     } catch (std::out_of_range& e) {
91138       {
91139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91140       };
91141     } catch (std::exception& e) {
91142       {
91143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91144       };
91145     } catch (Dali::DaliException e) {
91146       {
91147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91148       };
91149     } catch (...) {
91150       {
91151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91152       };
91153     }
91154   }
91155
91156   jresult = (unsigned long)result;
91157   return jresult;
91158 }
91159
91160
91161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
91162   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91163   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91164
91165   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91166   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91167   {
91168     try {
91169       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
91170     } catch (std::out_of_range& e) {
91171       {
91172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91173       };
91174     } catch (std::exception& e) {
91175       {
91176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91177       };
91178     } catch (Dali::DaliException e) {
91179       {
91180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91181       };
91182     } catch (...) {
91183       {
91184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91185       };
91186     }
91187   }
91188
91189 }
91190
91191
91192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
91193   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91194   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91195
91196   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91197   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91198   {
91199     try {
91200       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
91201     } catch (std::out_of_range& e) {
91202       {
91203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91204       };
91205     } catch (std::exception& e) {
91206       {
91207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91208       };
91209     } catch (Dali::DaliException e) {
91210       {
91211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91212       };
91213     } catch (...) {
91214       {
91215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91216       };
91217     }
91218   }
91219
91220 }
91221
91222
91223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
91224   unsigned int jresult ;
91225   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91226   Dali::Toolkit::Button arg2 ;
91227   Dali::Toolkit::Button *argp2 ;
91228   bool result;
91229
91230   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91231   argp2 = (Dali::Toolkit::Button *)jarg2;
91232   if (!argp2) {
91233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
91234     return 0;
91235   }
91236   arg2 = *argp2;
91237   {
91238     try {
91239       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
91240     } catch (std::out_of_range& e) {
91241       {
91242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91243       };
91244     } catch (std::exception& e) {
91245       {
91246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91247       };
91248     } catch (Dali::DaliException e) {
91249       {
91250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91251       };
91252     } catch (...) {
91253       {
91254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91255       };
91256     }
91257   }
91258
91259   jresult = result;
91260   return jresult;
91261 }
91262
91263
91264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
91265   void * jresult ;
91266   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
91267
91268   {
91269     try {
91270       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
91271     } catch (std::out_of_range& e) {
91272       {
91273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91274       };
91275     } catch (std::exception& e) {
91276       {
91277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91278       };
91279     } catch (Dali::DaliException e) {
91280       {
91281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91282       };
91283     } catch (...) {
91284       {
91285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91286       };
91287     }
91288   }
91289
91290   jresult = (void *)result;
91291   return jresult;
91292 }
91293
91294
91295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
91296   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91297
91298   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91299   {
91300     try {
91301       delete arg1;
91302     } catch (std::out_of_range& e) {
91303       {
91304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91305       };
91306     } catch (std::exception& e) {
91307       {
91308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91309       };
91310     } catch (Dali::DaliException e) {
91311       {
91312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91313       };
91314     } catch (...) {
91315       {
91316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91317       };
91318     }
91319   }
91320
91321 }
91322
91323
91324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
91325   unsigned int jresult ;
91326   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91327   bool result;
91328
91329   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91330   {
91331     try {
91332       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91333     } catch (std::out_of_range& e) {
91334       {
91335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91336       };
91337     } catch (std::exception& e) {
91338       {
91339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91340       };
91341     } catch (Dali::DaliException e) {
91342       {
91343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91344       };
91345     } catch (...) {
91346       {
91347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91348       };
91349     }
91350   }
91351
91352   jresult = result;
91353   return jresult;
91354 }
91355
91356
91357 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
91358   unsigned long jresult ;
91359   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91360   std::size_t result;
91361
91362   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91363   {
91364     try {
91365       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91366     } catch (std::out_of_range& e) {
91367       {
91368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91369       };
91370     } catch (std::exception& e) {
91371       {
91372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91373       };
91374     } catch (Dali::DaliException e) {
91375       {
91376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91377       };
91378     } catch (...) {
91379       {
91380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91381       };
91382     }
91383   }
91384
91385   jresult = (unsigned long)result;
91386   return jresult;
91387 }
91388
91389
91390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
91391   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91392   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91393
91394   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91395   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91396   {
91397     try {
91398       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
91399     } catch (std::out_of_range& e) {
91400       {
91401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91402       };
91403     } catch (std::exception& e) {
91404       {
91405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91406       };
91407     } catch (Dali::DaliException e) {
91408       {
91409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91410       };
91411     } catch (...) {
91412       {
91413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91414       };
91415     }
91416   }
91417
91418 }
91419
91420
91421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
91422   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91423   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91424
91425   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91426   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91427   {
91428     try {
91429       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
91430     } catch (std::out_of_range& e) {
91431       {
91432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91433       };
91434     } catch (std::exception& e) {
91435       {
91436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91437       };
91438     } catch (Dali::DaliException e) {
91439       {
91440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91441       };
91442     } catch (...) {
91443       {
91444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91445       };
91446     }
91447   }
91448
91449 }
91450
91451
91452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
91453   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91454   Dali::Toolkit::GaussianBlurView arg2 ;
91455   Dali::Toolkit::GaussianBlurView *argp2 ;
91456
91457   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91458   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
91459   if (!argp2) {
91460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
91461     return ;
91462   }
91463   arg2 = *argp2;
91464   {
91465     try {
91466       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
91467     } catch (std::out_of_range& e) {
91468       {
91469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91470       };
91471     } catch (std::exception& e) {
91472       {
91473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91474       };
91475     } catch (Dali::DaliException e) {
91476       {
91477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91478       };
91479     } catch (...) {
91480       {
91481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91482       };
91483     }
91484   }
91485
91486 }
91487
91488
91489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
91490   void * jresult ;
91491   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
91492
91493   {
91494     try {
91495       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
91496     } catch (std::out_of_range& e) {
91497       {
91498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91499       };
91500     } catch (std::exception& e) {
91501       {
91502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91503       };
91504     } catch (Dali::DaliException e) {
91505       {
91506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91507       };
91508     } catch (...) {
91509       {
91510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91511       };
91512     }
91513   }
91514
91515   jresult = (void *)result;
91516   return jresult;
91517 }
91518
91519
91520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
91521   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91522
91523   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91524   {
91525     try {
91526       delete arg1;
91527     } catch (std::out_of_range& e) {
91528       {
91529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91530       };
91531     } catch (std::exception& e) {
91532       {
91533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91534       };
91535     } catch (Dali::DaliException e) {
91536       {
91537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91538       };
91539     } catch (...) {
91540       {
91541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91542       };
91543     }
91544   }
91545
91546 }
91547
91548
91549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
91550   unsigned int jresult ;
91551   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91552   bool result;
91553
91554   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91555   {
91556     try {
91557       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);
91558     } catch (std::out_of_range& e) {
91559       {
91560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91561       };
91562     } catch (std::exception& e) {
91563       {
91564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91565       };
91566     } catch (Dali::DaliException e) {
91567       {
91568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91569       };
91570     } catch (...) {
91571       {
91572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91573       };
91574     }
91575   }
91576
91577   jresult = result;
91578   return jresult;
91579 }
91580
91581
91582 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
91583   unsigned long jresult ;
91584   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91585   std::size_t result;
91586
91587   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91588   {
91589     try {
91590       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);
91591     } catch (std::out_of_range& e) {
91592       {
91593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91594       };
91595     } catch (std::exception& e) {
91596       {
91597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91598       };
91599     } catch (Dali::DaliException e) {
91600       {
91601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91602       };
91603     } catch (...) {
91604       {
91605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91606       };
91607     }
91608   }
91609
91610   jresult = (unsigned long)result;
91611   return jresult;
91612 }
91613
91614
91615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
91616   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91617   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91618
91619   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91620   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91621   {
91622     try {
91623       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
91624     } catch (std::out_of_range& e) {
91625       {
91626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91627       };
91628     } catch (std::exception& e) {
91629       {
91630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91631       };
91632     } catch (Dali::DaliException e) {
91633       {
91634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91635       };
91636     } catch (...) {
91637       {
91638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91639       };
91640     }
91641   }
91642
91643 }
91644
91645
91646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
91647   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91648   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91649
91650   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91651   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91652   {
91653     try {
91654       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
91655     } catch (std::out_of_range& e) {
91656       {
91657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91658       };
91659     } catch (std::exception& e) {
91660       {
91661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91662       };
91663     } catch (Dali::DaliException e) {
91664       {
91665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91666       };
91667     } catch (...) {
91668       {
91669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91670       };
91671     }
91672   }
91673
91674 }
91675
91676
91677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
91678   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91679   Dali::Toolkit::PageTurnView arg2 ;
91680   unsigned int arg3 ;
91681   bool arg4 ;
91682   Dali::Toolkit::PageTurnView *argp2 ;
91683
91684   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91685   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
91686   if (!argp2) {
91687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
91688     return ;
91689   }
91690   arg2 = *argp2;
91691   arg3 = (unsigned int)jarg3;
91692   arg4 = jarg4 ? true : false;
91693   {
91694     try {
91695       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
91696     } catch (std::out_of_range& e) {
91697       {
91698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91699       };
91700     } catch (std::exception& e) {
91701       {
91702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91703       };
91704     } catch (Dali::DaliException e) {
91705       {
91706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91707       };
91708     } catch (...) {
91709       {
91710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91711       };
91712     }
91713   }
91714
91715 }
91716
91717
91718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
91719   void * jresult ;
91720   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
91721
91722   {
91723     try {
91724       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
91725     } catch (std::out_of_range& e) {
91726       {
91727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91728       };
91729     } catch (std::exception& e) {
91730       {
91731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91732       };
91733     } catch (Dali::DaliException e) {
91734       {
91735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91736       };
91737     } catch (...) {
91738       {
91739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91740       };
91741     }
91742   }
91743
91744   jresult = (void *)result;
91745   return jresult;
91746 }
91747
91748
91749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
91750   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91751
91752   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91753   {
91754     try {
91755       delete arg1;
91756     } catch (std::out_of_range& e) {
91757       {
91758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91759       };
91760     } catch (std::exception& e) {
91761       {
91762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91763       };
91764     } catch (Dali::DaliException e) {
91765       {
91766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91767       };
91768     } catch (...) {
91769       {
91770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91771       };
91772     }
91773   }
91774
91775 }
91776
91777
91778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
91779   unsigned int jresult ;
91780   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91781   bool result;
91782
91783   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91784   {
91785     try {
91786       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
91787     } catch (std::out_of_range& e) {
91788       {
91789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91790       };
91791     } catch (std::exception& e) {
91792       {
91793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91794       };
91795     } catch (Dali::DaliException e) {
91796       {
91797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91798       };
91799     } catch (...) {
91800       {
91801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91802       };
91803     }
91804   }
91805
91806   jresult = result;
91807   return jresult;
91808 }
91809
91810
91811 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
91812   unsigned long jresult ;
91813   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91814   std::size_t result;
91815
91816   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91817   {
91818     try {
91819       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
91820     } catch (std::out_of_range& e) {
91821       {
91822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91823       };
91824     } catch (std::exception& e) {
91825       {
91826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91827       };
91828     } catch (Dali::DaliException e) {
91829       {
91830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91831       };
91832     } catch (...) {
91833       {
91834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91835       };
91836     }
91837   }
91838
91839   jresult = (unsigned long)result;
91840   return jresult;
91841 }
91842
91843
91844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
91845   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91846   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
91847
91848   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91849   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
91850   {
91851     try {
91852       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
91853     } catch (std::out_of_range& e) {
91854       {
91855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91856       };
91857     } catch (std::exception& e) {
91858       {
91859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91860       };
91861     } catch (Dali::DaliException e) {
91862       {
91863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91864       };
91865     } catch (...) {
91866       {
91867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91868       };
91869     }
91870   }
91871
91872 }
91873
91874
91875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
91876   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91877   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
91878
91879   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91880   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
91881   {
91882     try {
91883       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
91884     } catch (std::out_of_range& e) {
91885       {
91886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91887       };
91888     } catch (std::exception& e) {
91889       {
91890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91891       };
91892     } catch (Dali::DaliException e) {
91893       {
91894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91895       };
91896     } catch (...) {
91897       {
91898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91899       };
91900     }
91901   }
91902
91903 }
91904
91905
91906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
91907   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91908   Dali::Toolkit::PageTurnView arg2 ;
91909   Dali::Toolkit::PageTurnView *argp2 ;
91910
91911   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91912   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
91913   if (!argp2) {
91914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
91915     return ;
91916   }
91917   arg2 = *argp2;
91918   {
91919     try {
91920       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
91921     } catch (std::out_of_range& e) {
91922       {
91923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91924       };
91925     } catch (std::exception& e) {
91926       {
91927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91928       };
91929     } catch (Dali::DaliException e) {
91930       {
91931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91932       };
91933     } catch (...) {
91934       {
91935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91936       };
91937     }
91938   }
91939
91940 }
91941
91942
91943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
91944   void * jresult ;
91945   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
91946
91947   {
91948     try {
91949       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
91950     } catch (std::out_of_range& e) {
91951       {
91952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91953       };
91954     } catch (std::exception& e) {
91955       {
91956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91957       };
91958     } catch (Dali::DaliException e) {
91959       {
91960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91961       };
91962     } catch (...) {
91963       {
91964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91965       };
91966     }
91967   }
91968
91969   jresult = (void *)result;
91970   return jresult;
91971 }
91972
91973
91974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
91975   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91976
91977   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91978   {
91979     try {
91980       delete arg1;
91981     } catch (std::out_of_range& e) {
91982       {
91983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91984       };
91985     } catch (std::exception& e) {
91986       {
91987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91988       };
91989     } catch (Dali::DaliException e) {
91990       {
91991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91992       };
91993     } catch (...) {
91994       {
91995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91996       };
91997     }
91998   }
91999
92000 }
92001
92002
92003 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
92004   unsigned int jresult ;
92005   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92006   bool result;
92007
92008   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92009   {
92010     try {
92011       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);
92012     } catch (std::out_of_range& e) {
92013       {
92014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92015       };
92016     } catch (std::exception& e) {
92017       {
92018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92019       };
92020     } catch (Dali::DaliException e) {
92021       {
92022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92023       };
92024     } catch (...) {
92025       {
92026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92027       };
92028     }
92029   }
92030
92031   jresult = result;
92032   return jresult;
92033 }
92034
92035
92036 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
92037   unsigned long jresult ;
92038   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92039   std::size_t result;
92040
92041   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92042   {
92043     try {
92044       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);
92045     } catch (std::out_of_range& e) {
92046       {
92047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92048       };
92049     } catch (std::exception& e) {
92050       {
92051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92052       };
92053     } catch (Dali::DaliException e) {
92054       {
92055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92056       };
92057     } catch (...) {
92058       {
92059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92060       };
92061     }
92062   }
92063
92064   jresult = (unsigned long)result;
92065   return jresult;
92066 }
92067
92068
92069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
92070   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92071   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92072
92073   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92074   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92075   {
92076     try {
92077       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
92078     } catch (std::out_of_range& e) {
92079       {
92080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92081       };
92082     } catch (std::exception& e) {
92083       {
92084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92085       };
92086     } catch (Dali::DaliException e) {
92087       {
92088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92089       };
92090     } catch (...) {
92091       {
92092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92093       };
92094     }
92095   }
92096
92097 }
92098
92099
92100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92101   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92102   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92103
92104   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92105   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92106   {
92107     try {
92108       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92109     } catch (std::out_of_range& e) {
92110       {
92111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92112       };
92113     } catch (std::exception& e) {
92114       {
92115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92116       };
92117     } catch (Dali::DaliException e) {
92118       {
92119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92120       };
92121     } catch (...) {
92122       {
92123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92124       };
92125     }
92126   }
92127
92128 }
92129
92130
92131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
92132   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92133   Dali::Toolkit::ProgressBar arg2 ;
92134   float arg3 ;
92135   float arg4 ;
92136   Dali::Toolkit::ProgressBar *argp2 ;
92137
92138   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92139   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
92140   if (!argp2) {
92141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
92142     return ;
92143   }
92144   arg2 = *argp2;
92145   arg3 = (float)jarg3;
92146   arg4 = (float)jarg4;
92147   {
92148     try {
92149       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
92150     } catch (std::out_of_range& e) {
92151       {
92152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92153       };
92154     } catch (std::exception& e) {
92155       {
92156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92157       };
92158     } catch (Dali::DaliException e) {
92159       {
92160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92161       };
92162     } catch (...) {
92163       {
92164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92165       };
92166     }
92167   }
92168
92169 }
92170
92171
92172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
92173   void * jresult ;
92174   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
92175
92176   {
92177     try {
92178       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
92179     } catch (std::out_of_range& e) {
92180       {
92181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92182       };
92183     } catch (std::exception& e) {
92184       {
92185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92186       };
92187     } catch (Dali::DaliException e) {
92188       {
92189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92190       };
92191     } catch (...) {
92192       {
92193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92194       };
92195     }
92196   }
92197
92198   jresult = (void *)result;
92199   return jresult;
92200 }
92201
92202
92203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
92204   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92205
92206   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92207   {
92208     try {
92209       delete arg1;
92210     } catch (std::out_of_range& e) {
92211       {
92212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92213       };
92214     } catch (std::exception& e) {
92215       {
92216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92217       };
92218     } catch (Dali::DaliException e) {
92219       {
92220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92221       };
92222     } catch (...) {
92223       {
92224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92225       };
92226     }
92227   }
92228
92229 }
92230
92231
92232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
92233   unsigned int jresult ;
92234   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92235   bool result;
92236
92237   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92238   {
92239     try {
92240       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);
92241     } catch (std::out_of_range& e) {
92242       {
92243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92244       };
92245     } catch (std::exception& e) {
92246       {
92247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92248       };
92249     } catch (Dali::DaliException e) {
92250       {
92251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92252       };
92253     } catch (...) {
92254       {
92255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92256       };
92257     }
92258   }
92259
92260   jresult = result;
92261   return jresult;
92262 }
92263
92264
92265 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
92266   unsigned long jresult ;
92267   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92268   std::size_t result;
92269
92270   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92271   {
92272     try {
92273       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);
92274     } catch (std::out_of_range& e) {
92275       {
92276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92277       };
92278     } catch (std::exception& e) {
92279       {
92280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92281       };
92282     } catch (Dali::DaliException e) {
92283       {
92284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92285       };
92286     } catch (...) {
92287       {
92288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92289       };
92290     }
92291   }
92292
92293   jresult = (unsigned long)result;
92294   return jresult;
92295 }
92296
92297
92298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
92299   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92300   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92301
92302   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92303   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92304   {
92305     try {
92306       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92307     } catch (std::out_of_range& e) {
92308       {
92309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92310       };
92311     } catch (std::exception& e) {
92312       {
92313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92314       };
92315     } catch (Dali::DaliException e) {
92316       {
92317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92318       };
92319     } catch (...) {
92320       {
92321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92322       };
92323     }
92324   }
92325
92326 }
92327
92328
92329 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
92330   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92331   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92332
92333   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92334   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92335   {
92336     try {
92337       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92338     } catch (std::out_of_range& e) {
92339       {
92340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92341       };
92342     } catch (std::exception& e) {
92343       {
92344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92345       };
92346     } catch (Dali::DaliException e) {
92347       {
92348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92349       };
92350     } catch (...) {
92351       {
92352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92353       };
92354     }
92355   }
92356
92357 }
92358
92359
92360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
92361   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92362   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
92363
92364   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92365   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
92366   if (!arg2) {
92367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
92368     return ;
92369   }
92370   {
92371     try {
92372       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
92373     } catch (std::out_of_range& e) {
92374       {
92375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92376       };
92377     } catch (std::exception& e) {
92378       {
92379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92380       };
92381     } catch (Dali::DaliException e) {
92382       {
92383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92384       };
92385     } catch (...) {
92386       {
92387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92388       };
92389     }
92390   }
92391
92392 }
92393
92394
92395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
92396   void * jresult ;
92397   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
92398
92399   {
92400     try {
92401       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
92402     } catch (std::out_of_range& e) {
92403       {
92404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92405       };
92406     } catch (std::exception& e) {
92407       {
92408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92409       };
92410     } catch (Dali::DaliException e) {
92411       {
92412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92413       };
92414     } catch (...) {
92415       {
92416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92417       };
92418     }
92419   }
92420
92421   jresult = (void *)result;
92422   return jresult;
92423 }
92424
92425
92426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
92427   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92428
92429   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92430   {
92431     try {
92432       delete arg1;
92433     } catch (std::out_of_range& e) {
92434       {
92435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92436       };
92437     } catch (std::exception& e) {
92438       {
92439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92440       };
92441     } catch (Dali::DaliException e) {
92442       {
92443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92444       };
92445     } catch (...) {
92446       {
92447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92448       };
92449     }
92450   }
92451
92452 }
92453
92454
92455 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
92456   unsigned int jresult ;
92457   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92458   bool result;
92459
92460   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92461   {
92462     try {
92463       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92464     } catch (std::out_of_range& e) {
92465       {
92466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92467       };
92468     } catch (std::exception& e) {
92469       {
92470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92471       };
92472     } catch (Dali::DaliException e) {
92473       {
92474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92475       };
92476     } catch (...) {
92477       {
92478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92479       };
92480     }
92481   }
92482
92483   jresult = result;
92484   return jresult;
92485 }
92486
92487
92488 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
92489   unsigned long jresult ;
92490   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92491   std::size_t result;
92492
92493   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92494   {
92495     try {
92496       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92497     } catch (std::out_of_range& e) {
92498       {
92499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92500       };
92501     } catch (std::exception& e) {
92502       {
92503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92504       };
92505     } catch (Dali::DaliException e) {
92506       {
92507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92508       };
92509     } catch (...) {
92510       {
92511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92512       };
92513     }
92514   }
92515
92516   jresult = (unsigned long)result;
92517   return jresult;
92518 }
92519
92520
92521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
92522   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92523   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92524
92525   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92526   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92527   {
92528     try {
92529       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92530     } catch (std::out_of_range& e) {
92531       {
92532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92533       };
92534     } catch (std::exception& e) {
92535       {
92536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92537       };
92538     } catch (Dali::DaliException e) {
92539       {
92540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92541       };
92542     } catch (...) {
92543       {
92544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92545       };
92546     }
92547   }
92548
92549 }
92550
92551
92552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
92553   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92554   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92555
92556   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92557   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92558   {
92559     try {
92560       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92561     } catch (std::out_of_range& e) {
92562       {
92563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92564       };
92565     } catch (std::exception& e) {
92566       {
92567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92568       };
92569     } catch (Dali::DaliException e) {
92570       {
92571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92572       };
92573     } catch (...) {
92574       {
92575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92576       };
92577     }
92578   }
92579
92580 }
92581
92582
92583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
92584   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92585   Dali::Vector2 *arg2 = 0 ;
92586
92587   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92588   arg2 = (Dali::Vector2 *)jarg2;
92589   if (!arg2) {
92590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
92591     return ;
92592   }
92593   {
92594     try {
92595       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
92596     } catch (std::out_of_range& e) {
92597       {
92598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92599       };
92600     } catch (std::exception& e) {
92601       {
92602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92603       };
92604     } catch (Dali::DaliException e) {
92605       {
92606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92607       };
92608     } catch (...) {
92609       {
92610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92611       };
92612     }
92613   }
92614
92615 }
92616
92617
92618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
92619   void * jresult ;
92620   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
92621
92622   {
92623     try {
92624       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
92625     } catch (std::out_of_range& e) {
92626       {
92627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92628       };
92629     } catch (std::exception& e) {
92630       {
92631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92632       };
92633     } catch (Dali::DaliException e) {
92634       {
92635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92636       };
92637     } catch (...) {
92638       {
92639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92640       };
92641     }
92642   }
92643
92644   jresult = (void *)result;
92645   return jresult;
92646 }
92647
92648
92649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
92650   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92651
92652   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92653   {
92654     try {
92655       delete arg1;
92656     } catch (std::out_of_range& e) {
92657       {
92658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92659       };
92660     } catch (std::exception& e) {
92661       {
92662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92663       };
92664     } catch (Dali::DaliException e) {
92665       {
92666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92667       };
92668     } catch (...) {
92669       {
92670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92671       };
92672     }
92673   }
92674
92675 }
92676
92677
92678
92679 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
92680   unsigned int jresult ;
92681   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92682   bool result;
92683
92684   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92685   {
92686     try {
92687       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);
92688     } catch (std::out_of_range& e) {
92689       {
92690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92691       };
92692     } catch (std::exception& e) {
92693       {
92694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92695       };
92696     } catch (Dali::DaliException e) {
92697       {
92698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92699       };
92700     } catch (...) {
92701       {
92702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92703       };
92704     }
92705   }
92706
92707   jresult = result;
92708   return jresult;
92709 }
92710
92711
92712 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
92713   unsigned long jresult ;
92714   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92715   std::size_t result;
92716
92717   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92718   {
92719     try {
92720       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);
92721     } catch (std::out_of_range& e) {
92722       {
92723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92724       };
92725     } catch (std::exception& e) {
92726       {
92727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92728       };
92729     } catch (Dali::DaliException e) {
92730       {
92731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92732       };
92733     } catch (...) {
92734       {
92735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92736       };
92737     }
92738   }
92739
92740   jresult = (unsigned long)result;
92741   return jresult;
92742 }
92743
92744
92745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
92746   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92747   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92748
92749   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92750   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92751   {
92752     try {
92753       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92754     } catch (std::out_of_range& e) {
92755       {
92756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92757       };
92758     } catch (std::exception& e) {
92759       {
92760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92761       };
92762     } catch (Dali::DaliException e) {
92763       {
92764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92765       };
92766     } catch (...) {
92767       {
92768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92769       };
92770     }
92771   }
92772
92773 }
92774
92775
92776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
92777   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92778   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92779
92780   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92781   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92782   {
92783     try {
92784       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92785     } catch (std::out_of_range& e) {
92786       {
92787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92788       };
92789     } catch (std::exception& e) {
92790       {
92791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92792       };
92793     } catch (Dali::DaliException e) {
92794       {
92795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92796       };
92797     } catch (...) {
92798       {
92799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92800       };
92801     }
92802   }
92803
92804 }
92805
92806
92807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
92808   unsigned int jresult ;
92809   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92810   Dali::Toolkit::Control arg2 ;
92811   Dali::KeyEvent *arg3 = 0 ;
92812   Dali::Toolkit::Control *argp2 ;
92813   bool result;
92814
92815   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92816   argp2 = (Dali::Toolkit::Control *)jarg2;
92817   if (!argp2) {
92818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92819     return 0;
92820   }
92821   arg2 = *argp2;
92822   arg3 = (Dali::KeyEvent *)jarg3;
92823   if (!arg3) {
92824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
92825     return 0;
92826   }
92827   {
92828     try {
92829       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);
92830     } catch (std::out_of_range& e) {
92831       {
92832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92833       };
92834     } catch (std::exception& e) {
92835       {
92836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92837       };
92838     } catch (Dali::DaliException e) {
92839       {
92840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92841       };
92842     } catch (...) {
92843       {
92844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92845       };
92846     }
92847   }
92848
92849   jresult = result;
92850   return jresult;
92851 }
92852
92853
92854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
92855   void * jresult ;
92856   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
92857
92858   {
92859     try {
92860       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
92861     } catch (std::out_of_range& e) {
92862       {
92863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92864       };
92865     } catch (std::exception& e) {
92866       {
92867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92868       };
92869     } catch (Dali::DaliException e) {
92870       {
92871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92872       };
92873     } catch (...) {
92874       {
92875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92876       };
92877     }
92878   }
92879
92880   jresult = (void *)result;
92881   return jresult;
92882 }
92883
92884
92885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
92886   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92887
92888   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92889   {
92890     try {
92891       delete arg1;
92892     } catch (std::out_of_range& e) {
92893       {
92894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92895       };
92896     } catch (std::exception& e) {
92897       {
92898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92899       };
92900     } catch (Dali::DaliException e) {
92901       {
92902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92903       };
92904     } catch (...) {
92905       {
92906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92907       };
92908     }
92909   }
92910
92911 }
92912
92913
92914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
92915   unsigned int jresult ;
92916   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92917   bool result;
92918
92919   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92920   {
92921     try {
92922       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92923     } catch (std::out_of_range& e) {
92924       {
92925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92926       };
92927     } catch (std::exception& e) {
92928       {
92929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92930       };
92931     } catch (Dali::DaliException e) {
92932       {
92933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92934       };
92935     } catch (...) {
92936       {
92937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92938       };
92939     }
92940   }
92941
92942   jresult = result;
92943   return jresult;
92944 }
92945
92946
92947 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
92948   unsigned long jresult ;
92949   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92950   std::size_t result;
92951
92952   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92953   {
92954     try {
92955       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92956     } catch (std::out_of_range& e) {
92957       {
92958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92959       };
92960     } catch (std::exception& e) {
92961       {
92962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92963       };
92964     } catch (Dali::DaliException e) {
92965       {
92966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92967       };
92968     } catch (...) {
92969       {
92970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92971       };
92972     }
92973   }
92974
92975   jresult = (unsigned long)result;
92976   return jresult;
92977 }
92978
92979
92980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
92981   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92982   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92983
92984   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92985   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92986   {
92987     try {
92988       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
92989     } catch (std::out_of_range& e) {
92990       {
92991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92992       };
92993     } catch (std::exception& e) {
92994       {
92995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92996       };
92997     } catch (Dali::DaliException e) {
92998       {
92999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93000       };
93001     } catch (...) {
93002       {
93003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93004       };
93005     }
93006   }
93007
93008 }
93009
93010
93011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
93012   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93013   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93014
93015   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93016   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93017   {
93018     try {
93019       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
93020     } catch (std::out_of_range& e) {
93021       {
93022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93023       };
93024     } catch (std::exception& e) {
93025       {
93026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93027       };
93028     } catch (Dali::DaliException e) {
93029       {
93030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93031       };
93032     } catch (...) {
93033       {
93034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93035       };
93036     }
93037   }
93038
93039 }
93040
93041
93042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
93043   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93044   Dali::Toolkit::Control arg2 ;
93045   Dali::Toolkit::Control *argp2 ;
93046
93047   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93048   argp2 = (Dali::Toolkit::Control *)jarg2;
93049   if (!argp2) {
93050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
93051     return ;
93052   }
93053   arg2 = *argp2;
93054   {
93055     try {
93056       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
93057     } catch (std::out_of_range& e) {
93058       {
93059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93060       };
93061     } catch (std::exception& e) {
93062       {
93063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93064       };
93065     } catch (Dali::DaliException e) {
93066       {
93067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93068       };
93069     } catch (...) {
93070       {
93071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93072       };
93073     }
93074   }
93075
93076 }
93077
93078
93079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
93080   void * jresult ;
93081   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
93082
93083   {
93084     try {
93085       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
93086     } catch (std::out_of_range& e) {
93087       {
93088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93089       };
93090     } catch (std::exception& e) {
93091       {
93092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93093       };
93094     } catch (Dali::DaliException e) {
93095       {
93096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93097       };
93098     } catch (...) {
93099       {
93100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93101       };
93102     }
93103   }
93104
93105   jresult = (void *)result;
93106   return jresult;
93107 }
93108
93109
93110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
93111   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93112
93113   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93114   {
93115     try {
93116       delete arg1;
93117     } catch (std::out_of_range& e) {
93118       {
93119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93120       };
93121     } catch (std::exception& e) {
93122       {
93123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93124       };
93125     } catch (Dali::DaliException e) {
93126       {
93127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93128       };
93129     } catch (...) {
93130       {
93131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93132       };
93133     }
93134   }
93135
93136 }
93137
93138
93139 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
93140   unsigned int jresult ;
93141   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93142   bool result;
93143
93144   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93145   {
93146     try {
93147       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93148     } catch (std::out_of_range& e) {
93149       {
93150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93151       };
93152     } catch (std::exception& e) {
93153       {
93154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93155       };
93156     } catch (Dali::DaliException e) {
93157       {
93158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93159       };
93160     } catch (...) {
93161       {
93162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93163       };
93164     }
93165   }
93166
93167   jresult = result;
93168   return jresult;
93169 }
93170
93171
93172 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
93173   unsigned long jresult ;
93174   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93175   std::size_t result;
93176
93177   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93178   {
93179     try {
93180       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93181     } catch (std::out_of_range& e) {
93182       {
93183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93184       };
93185     } catch (std::exception& e) {
93186       {
93187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93188       };
93189     } catch (Dali::DaliException e) {
93190       {
93191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93192       };
93193     } catch (...) {
93194       {
93195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93196       };
93197     }
93198   }
93199
93200   jresult = (unsigned long)result;
93201   return jresult;
93202 }
93203
93204
93205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
93206   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93207   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93208
93209   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93210   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93211   {
93212     try {
93213       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
93214     } catch (std::out_of_range& e) {
93215       {
93216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93217       };
93218     } catch (std::exception& e) {
93219       {
93220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93221       };
93222     } catch (Dali::DaliException e) {
93223       {
93224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93225       };
93226     } catch (...) {
93227       {
93228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93229       };
93230     }
93231   }
93232
93233 }
93234
93235
93236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
93237   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93238   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93239
93240   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93241   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93242   {
93243     try {
93244       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
93245     } catch (std::out_of_range& e) {
93246       {
93247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93248       };
93249     } catch (std::exception& e) {
93250       {
93251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93252       };
93253     } catch (Dali::DaliException e) {
93254       {
93255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93256       };
93257     } catch (...) {
93258       {
93259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93260       };
93261     }
93262   }
93263
93264 }
93265
93266
93267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
93268   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93269   Dali::Toolkit::VideoView *arg2 = 0 ;
93270
93271   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93272   arg2 = (Dali::Toolkit::VideoView *)jarg2;
93273   if (!arg2) {
93274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
93275     return ;
93276   }
93277   {
93278     try {
93279       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
93280     } catch (std::out_of_range& e) {
93281       {
93282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93283       };
93284     } catch (std::exception& e) {
93285       {
93286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93287       };
93288     } catch (Dali::DaliException e) {
93289       {
93290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93291       };
93292     } catch (...) {
93293       {
93294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93295       };
93296     }
93297   }
93298
93299 }
93300
93301
93302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
93303   void * jresult ;
93304   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
93305
93306   {
93307     try {
93308       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
93309     } catch (std::out_of_range& e) {
93310       {
93311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93312       };
93313     } catch (std::exception& e) {
93314       {
93315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93316       };
93317     } catch (Dali::DaliException e) {
93318       {
93319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93320       };
93321     } catch (...) {
93322       {
93323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93324       };
93325     }
93326   }
93327
93328   jresult = (void *)result;
93329   return jresult;
93330 }
93331
93332
93333 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
93334   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93335
93336   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93337   {
93338     try {
93339       delete arg1;
93340     } catch (std::out_of_range& e) {
93341       {
93342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93343       };
93344     } catch (std::exception& e) {
93345       {
93346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93347       };
93348     } catch (Dali::DaliException e) {
93349       {
93350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93351       };
93352     } catch (...) {
93353       {
93354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93355       };
93356     }
93357   }
93358
93359 }
93360
93361
93362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
93363   unsigned int jresult ;
93364   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93365   bool result;
93366
93367   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93368   {
93369     try {
93370       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93371     } catch (std::out_of_range& e) {
93372       {
93373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93374       };
93375     } catch (std::exception& e) {
93376       {
93377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93378       };
93379     } catch (Dali::DaliException e) {
93380       {
93381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93382       };
93383     } catch (...) {
93384       {
93385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93386       };
93387     }
93388   }
93389
93390   jresult = result;
93391   return jresult;
93392 }
93393
93394
93395 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
93396   unsigned long jresult ;
93397   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93398   std::size_t result;
93399
93400   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93401   {
93402     try {
93403       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93404     } catch (std::out_of_range& e) {
93405       {
93406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93407       };
93408     } catch (std::exception& e) {
93409       {
93410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93411       };
93412     } catch (Dali::DaliException e) {
93413       {
93414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93415       };
93416     } catch (...) {
93417       {
93418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93419       };
93420     }
93421   }
93422
93423   jresult = (unsigned long)result;
93424   return jresult;
93425 }
93426
93427
93428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
93429   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93430   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93431
93432   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93433   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93434   {
93435     try {
93436       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
93437     } catch (std::out_of_range& e) {
93438       {
93439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93440       };
93441     } catch (std::exception& e) {
93442       {
93443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93444       };
93445     } catch (Dali::DaliException e) {
93446       {
93447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93448       };
93449     } catch (...) {
93450       {
93451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93452       };
93453     }
93454   }
93455
93456 }
93457
93458
93459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
93460   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93461   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93462
93463   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93464   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93465   {
93466     try {
93467       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
93468     } catch (std::out_of_range& e) {
93469       {
93470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93471       };
93472     } catch (std::exception& e) {
93473       {
93474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93475       };
93476     } catch (Dali::DaliException e) {
93477       {
93478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93479       };
93480     } catch (...) {
93481       {
93482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93483       };
93484     }
93485   }
93486
93487 }
93488
93489
93490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
93491   unsigned int jresult ;
93492   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93493   Dali::Toolkit::Slider arg2 ;
93494   float arg3 ;
93495   Dali::Toolkit::Slider *argp2 ;
93496   bool result;
93497
93498   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93499   argp2 = (Dali::Toolkit::Slider *)jarg2;
93500   if (!argp2) {
93501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93502     return 0;
93503   }
93504   arg2 = *argp2;
93505   arg3 = (float)jarg3;
93506   {
93507     try {
93508       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
93509     } catch (std::out_of_range& e) {
93510       {
93511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93512       };
93513     } catch (std::exception& e) {
93514       {
93515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93516       };
93517     } catch (Dali::DaliException e) {
93518       {
93519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93520       };
93521     } catch (...) {
93522       {
93523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93524       };
93525     }
93526   }
93527
93528   jresult = result;
93529   return jresult;
93530 }
93531
93532
93533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
93534   void * jresult ;
93535   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
93536
93537   {
93538     try {
93539       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
93540     } catch (std::out_of_range& e) {
93541       {
93542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93543       };
93544     } catch (std::exception& e) {
93545       {
93546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93547       };
93548     } catch (Dali::DaliException e) {
93549       {
93550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93551       };
93552     } catch (...) {
93553       {
93554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93555       };
93556     }
93557   }
93558
93559   jresult = (void *)result;
93560   return jresult;
93561 }
93562
93563
93564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
93565   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93566
93567   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93568   {
93569     try {
93570       delete arg1;
93571     } catch (std::out_of_range& e) {
93572       {
93573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93574       };
93575     } catch (std::exception& e) {
93576       {
93577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93578       };
93579     } catch (Dali::DaliException e) {
93580       {
93581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93582       };
93583     } catch (...) {
93584       {
93585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93586       };
93587     }
93588   }
93589
93590 }
93591
93592
93593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
93594   unsigned int jresult ;
93595   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93596   bool result;
93597
93598   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93599   {
93600     try {
93601       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93602     } catch (std::out_of_range& e) {
93603       {
93604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93605       };
93606     } catch (std::exception& e) {
93607       {
93608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93609       };
93610     } catch (Dali::DaliException e) {
93611       {
93612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93613       };
93614     } catch (...) {
93615       {
93616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93617       };
93618     }
93619   }
93620
93621   jresult = result;
93622   return jresult;
93623 }
93624
93625
93626 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
93627   unsigned long jresult ;
93628   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93629   std::size_t result;
93630
93631   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93632   {
93633     try {
93634       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93635     } catch (std::out_of_range& e) {
93636       {
93637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93638       };
93639     } catch (std::exception& e) {
93640       {
93641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93642       };
93643     } catch (Dali::DaliException e) {
93644       {
93645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93646       };
93647     } catch (...) {
93648       {
93649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93650       };
93651     }
93652   }
93653
93654   jresult = (unsigned long)result;
93655   return jresult;
93656 }
93657
93658
93659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
93660   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93661   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93662
93663   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93664   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93665   {
93666     try {
93667       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
93668     } catch (std::out_of_range& e) {
93669       {
93670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93671       };
93672     } catch (std::exception& e) {
93673       {
93674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93675       };
93676     } catch (Dali::DaliException e) {
93677       {
93678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93679       };
93680     } catch (...) {
93681       {
93682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93683       };
93684     }
93685   }
93686
93687 }
93688
93689
93690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
93691   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93692   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93693
93694   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93695   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93696   {
93697     try {
93698       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
93699     } catch (std::out_of_range& e) {
93700       {
93701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93702       };
93703     } catch (std::exception& e) {
93704       {
93705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93706       };
93707     } catch (Dali::DaliException e) {
93708       {
93709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93710       };
93711     } catch (...) {
93712       {
93713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93714       };
93715     }
93716   }
93717
93718 }
93719
93720
93721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
93722   unsigned int jresult ;
93723   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93724   Dali::Toolkit::Slider arg2 ;
93725   int arg3 ;
93726   Dali::Toolkit::Slider *argp2 ;
93727   bool result;
93728
93729   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93730   argp2 = (Dali::Toolkit::Slider *)jarg2;
93731   if (!argp2) {
93732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93733     return 0;
93734   }
93735   arg2 = *argp2;
93736   arg3 = (int)jarg3;
93737   {
93738     try {
93739       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
93740     } catch (std::out_of_range& e) {
93741       {
93742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93743       };
93744     } catch (std::exception& e) {
93745       {
93746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93747       };
93748     } catch (Dali::DaliException e) {
93749       {
93750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93751       };
93752     } catch (...) {
93753       {
93754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93755       };
93756     }
93757   }
93758
93759   jresult = result;
93760   return jresult;
93761 }
93762
93763
93764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
93765   void * jresult ;
93766   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
93767
93768   {
93769     try {
93770       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
93771     } catch (std::out_of_range& e) {
93772       {
93773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93774       };
93775     } catch (std::exception& e) {
93776       {
93777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93778       };
93779     } catch (Dali::DaliException e) {
93780       {
93781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93782       };
93783     } catch (...) {
93784       {
93785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93786       };
93787     }
93788   }
93789
93790   jresult = (void *)result;
93791   return jresult;
93792 }
93793
93794
93795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
93796   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93797
93798   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93799   {
93800     try {
93801       delete arg1;
93802     } catch (std::out_of_range& e) {
93803       {
93804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93805       };
93806     } catch (std::exception& e) {
93807       {
93808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93809       };
93810     } catch (Dali::DaliException e) {
93811       {
93812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93813       };
93814     } catch (...) {
93815       {
93816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93817       };
93818     }
93819   }
93820
93821 }
93822
93823
93824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
93825   void * jresult ;
93826   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93827
93828   {
93829     try {
93830       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
93831     } catch (std::out_of_range& e) {
93832       {
93833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93834       };
93835     } catch (std::exception& e) {
93836       {
93837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93838       };
93839     } catch (Dali::DaliException e) {
93840       {
93841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93842       };
93843     } catch (...) {
93844       {
93845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93846       };
93847     }
93848   }
93849
93850   jresult = (void *)result;
93851   return jresult;
93852 }
93853
93854
93855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
93856   void * jresult ;
93857   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
93858   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93859
93860   arg1 = (Dali::Toolkit::Ruler *)jarg1;
93861   {
93862     try {
93863       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
93864     } catch (std::out_of_range& e) {
93865       {
93866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93867       };
93868     } catch (std::exception& e) {
93869       {
93870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93871       };
93872     } catch (Dali::DaliException e) {
93873       {
93874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93875       };
93876     } catch (...) {
93877       {
93878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93879       };
93880     }
93881   }
93882
93883   jresult = (void *)result;
93884   return jresult;
93885 }
93886
93887
93888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
93889   void * jresult ;
93890   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
93891   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93892
93893   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93894   if (!arg1) {
93895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93896     return 0;
93897   }
93898   {
93899     try {
93900       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
93901     } catch (std::out_of_range& e) {
93902       {
93903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93904       };
93905     } catch (std::exception& e) {
93906       {
93907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93908       };
93909     } catch (Dali::DaliException e) {
93910       {
93911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93912       };
93913     } catch (...) {
93914       {
93915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93916       };
93917     }
93918   }
93919
93920   jresult = (void *)result;
93921   return jresult;
93922 }
93923
93924
93925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
93926   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93927
93928   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93929   {
93930     try {
93931       delete arg1;
93932     } catch (std::out_of_range& e) {
93933       {
93934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93935       };
93936     } catch (std::exception& e) {
93937       {
93938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93939       };
93940     } catch (Dali::DaliException e) {
93941       {
93942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93943       };
93944     } catch (...) {
93945       {
93946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93947       };
93948     }
93949   }
93950
93951 }
93952
93953
93954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
93955   void * jresult ;
93956   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93957   Dali::Toolkit::Ruler *result = 0 ;
93958
93959   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93960   {
93961     try {
93962       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
93963     } catch (std::out_of_range& e) {
93964       {
93965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93966       };
93967     } catch (std::exception& e) {
93968       {
93969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93970       };
93971     } catch (Dali::DaliException e) {
93972       {
93973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93974       };
93975     } catch (...) {
93976       {
93977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93978       };
93979     }
93980   }
93981
93982   jresult = (void *)result;
93983   return jresult;
93984 }
93985
93986
93987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
93988   void * jresult ;
93989   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93990   Dali::Toolkit::Ruler *result = 0 ;
93991
93992   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93993   {
93994     try {
93995       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
93996     } catch (std::out_of_range& e) {
93997       {
93998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93999       };
94000     } catch (std::exception& e) {
94001       {
94002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94003       };
94004     } catch (Dali::DaliException e) {
94005       {
94006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94007       };
94008     } catch (...) {
94009       {
94010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94011       };
94012     }
94013   }
94014
94015   jresult = (void *)result;
94016   return jresult;
94017 }
94018
94019
94020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
94021   void * jresult ;
94022   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94023   Dali::Toolkit::Ruler *result = 0 ;
94024
94025   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94026   {
94027     try {
94028       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
94029     } catch (std::out_of_range& e) {
94030       {
94031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94032       };
94033     } catch (std::exception& e) {
94034       {
94035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94036       };
94037     } catch (Dali::DaliException e) {
94038       {
94039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94040       };
94041     } catch (...) {
94042       {
94043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94044       };
94045     }
94046   }
94047
94048   jresult = (void *)result;
94049   return jresult;
94050 }
94051
94052
94053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
94054   void * jresult ;
94055   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94056   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
94057   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94058
94059   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94060   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
94061   if (!arg2) {
94062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
94063     return 0;
94064   }
94065   {
94066     try {
94067       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
94068     } catch (std::out_of_range& e) {
94069       {
94070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94071       };
94072     } catch (std::exception& e) {
94073       {
94074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94075       };
94076     } catch (Dali::DaliException e) {
94077       {
94078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94079       };
94080     } catch (...) {
94081       {
94082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94083       };
94084     }
94085   }
94086
94087   jresult = (void *)result;
94088   return jresult;
94089 }
94090
94091
94092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
94093   void * jresult ;
94094   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94095   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94096   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94097
94098   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94099   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94100   {
94101     try {
94102       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
94103     } catch (std::out_of_range& e) {
94104       {
94105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94106       };
94107     } catch (std::exception& e) {
94108       {
94109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94110       };
94111     } catch (Dali::DaliException e) {
94112       {
94113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94114       };
94115     } catch (...) {
94116       {
94117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94118       };
94119     }
94120   }
94121
94122   jresult = (void *)result;
94123   return jresult;
94124 }
94125
94126
94127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
94128   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94129
94130   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94131   {
94132     try {
94133       (arg1)->Reset();
94134     } catch (std::out_of_range& e) {
94135       {
94136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94137       };
94138     } catch (std::exception& e) {
94139       {
94140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94141       };
94142     } catch (Dali::DaliException e) {
94143       {
94144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94145       };
94146     } catch (...) {
94147       {
94148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94149       };
94150     }
94151   }
94152
94153 }
94154
94155
94156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
94157   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94158   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94159
94160   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94161   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94162   {
94163     try {
94164       (arg1)->Reset(arg2);
94165     } catch (std::out_of_range& e) {
94166       {
94167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94168       };
94169     } catch (std::exception& e) {
94170       {
94171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94172       };
94173     } catch (Dali::DaliException e) {
94174       {
94175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94176       };
94177     } catch (...) {
94178       {
94179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94180       };
94181     }
94182   }
94183
94184 }
94185
94186
94187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
94188   void * jresult ;
94189   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94190   Dali::Toolkit::Ruler *result = 0 ;
94191
94192   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94193   {
94194     try {
94195       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
94196     } catch (std::out_of_range& e) {
94197       {
94198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94199       };
94200     } catch (std::exception& e) {
94201       {
94202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94203       };
94204     } catch (Dali::DaliException e) {
94205       {
94206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94207       };
94208     } catch (...) {
94209       {
94210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94211       };
94212     }
94213   }
94214
94215   jresult = (void *)result;
94216   return jresult;
94217 }
94218
94219
94220 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
94221   float jresult ;
94222   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94223   float arg2 ;
94224   float arg3 ;
94225   float result;
94226
94227   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94228   arg2 = (float)jarg2;
94229   arg3 = (float)jarg3;
94230   {
94231     try {
94232       result = (float)(*arg1)->Snap(arg2,arg3);
94233     } catch (std::out_of_range& e) {
94234       {
94235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94236       };
94237     } catch (std::exception& e) {
94238       {
94239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94240       };
94241     } catch (Dali::DaliException e) {
94242       {
94243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94244       };
94245     } catch (...) {
94246       {
94247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94248       };
94249     }
94250   }
94251
94252   jresult = result;
94253   return jresult;
94254 }
94255
94256
94257 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
94258   float jresult ;
94259   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94260   float arg2 ;
94261   float result;
94262
94263   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94264   arg2 = (float)jarg2;
94265   {
94266     try {
94267       result = (float)(*arg1)->Snap(arg2);
94268     } catch (std::out_of_range& e) {
94269       {
94270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94271       };
94272     } catch (std::exception& e) {
94273       {
94274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94275       };
94276     } catch (Dali::DaliException e) {
94277       {
94278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94279       };
94280     } catch (...) {
94281       {
94282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94283       };
94284     }
94285   }
94286
94287   jresult = result;
94288   return jresult;
94289 }
94290
94291
94292 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
94293   float jresult ;
94294   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94295   unsigned int arg2 ;
94296   unsigned int *arg3 = 0 ;
94297   bool arg4 ;
94298   float result;
94299
94300   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94301   arg2 = (unsigned int)jarg2;
94302   arg3 = (unsigned int *)jarg3;
94303   arg4 = jarg4 ? true : false;
94304   {
94305     try {
94306       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
94307     } catch (std::out_of_range& e) {
94308       {
94309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94310       };
94311     } catch (std::exception& e) {
94312       {
94313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94314       };
94315     } catch (Dali::DaliException e) {
94316       {
94317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94318       };
94319     } catch (...) {
94320       {
94321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94322       };
94323     }
94324   }
94325
94326   jresult = result;
94327   return jresult;
94328 }
94329
94330
94331 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
94332   unsigned int jresult ;
94333   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94334   float arg2 ;
94335   bool arg3 ;
94336   unsigned int result;
94337
94338   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94339   arg2 = (float)jarg2;
94340   arg3 = jarg3 ? true : false;
94341   {
94342     try {
94343       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
94344     } catch (std::out_of_range& e) {
94345       {
94346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94347       };
94348     } catch (std::exception& e) {
94349       {
94350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94351       };
94352     } catch (Dali::DaliException e) {
94353       {
94354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94355       };
94356     } catch (...) {
94357       {
94358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94359       };
94360     }
94361   }
94362
94363   jresult = result;
94364   return jresult;
94365 }
94366
94367
94368 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
94369   unsigned int jresult ;
94370   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94371   unsigned int result;
94372
94373   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94374   {
94375     try {
94376       result = (unsigned int)(*arg1)->GetTotalPages();
94377     } catch (std::out_of_range& e) {
94378       {
94379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94380       };
94381     } catch (std::exception& e) {
94382       {
94383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94384       };
94385     } catch (Dali::DaliException e) {
94386       {
94387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94388       };
94389     } catch (...) {
94390       {
94391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94392       };
94393     }
94394   }
94395
94396   jresult = result;
94397   return jresult;
94398 }
94399
94400
94401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
94402   int jresult ;
94403   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94404   Dali::Toolkit::Ruler::RulerType result;
94405
94406   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94407   {
94408     try {
94409       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
94410     } catch (std::out_of_range& e) {
94411       {
94412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94413       };
94414     } catch (std::exception& e) {
94415       {
94416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94417       };
94418     } catch (Dali::DaliException e) {
94419       {
94420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94421       };
94422     } catch (...) {
94423       {
94424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94425       };
94426     }
94427   }
94428
94429   jresult = (int)result;
94430   return jresult;
94431 }
94432
94433
94434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
94435   unsigned int jresult ;
94436   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94437   bool result;
94438
94439   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94440   {
94441     try {
94442       result = (bool)(*arg1)->IsEnabled();
94443     } catch (std::out_of_range& e) {
94444       {
94445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94446       };
94447     } catch (std::exception& e) {
94448       {
94449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94450       };
94451     } catch (Dali::DaliException e) {
94452       {
94453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94454       };
94455     } catch (...) {
94456       {
94457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94458       };
94459     }
94460   }
94461
94462   jresult = result;
94463   return jresult;
94464 }
94465
94466
94467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
94468   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94469
94470   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94471   {
94472     try {
94473       (*arg1)->Enable();
94474     } catch (std::out_of_range& e) {
94475       {
94476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94477       };
94478     } catch (std::exception& e) {
94479       {
94480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94481       };
94482     } catch (Dali::DaliException e) {
94483       {
94484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94485       };
94486     } catch (...) {
94487       {
94488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94489       };
94490     }
94491   }
94492
94493 }
94494
94495
94496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
94497   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94498
94499   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94500   {
94501     try {
94502       (*arg1)->Disable();
94503     } catch (std::out_of_range& e) {
94504       {
94505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94506       };
94507     } catch (std::exception& e) {
94508       {
94509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94510       };
94511     } catch (Dali::DaliException e) {
94512       {
94513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94514       };
94515     } catch (...) {
94516       {
94517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94518       };
94519     }
94520   }
94521
94522 }
94523
94524
94525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
94526   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94527   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
94528   Dali::Toolkit::RulerDomain *argp2 ;
94529
94530   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94531   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
94532   if (!argp2) {
94533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
94534     return ;
94535   }
94536   arg2 = *argp2;
94537   {
94538     try {
94539       (*arg1)->SetDomain(arg2);
94540     } catch (std::out_of_range& e) {
94541       {
94542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94543       };
94544     } catch (std::exception& e) {
94545       {
94546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94547       };
94548     } catch (Dali::DaliException e) {
94549       {
94550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94551       };
94552     } catch (...) {
94553       {
94554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94555       };
94556     }
94557   }
94558
94559 }
94560
94561
94562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
94563   void * jresult ;
94564   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94565   Dali::Toolkit::RulerDomain *result = 0 ;
94566
94567   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94568   {
94569     try {
94570       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
94571     } catch (std::out_of_range& e) {
94572       {
94573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94574       };
94575     } catch (std::exception& e) {
94576       {
94577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94578       };
94579     } catch (Dali::DaliException e) {
94580       {
94581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94582       };
94583     } catch (...) {
94584       {
94585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94586       };
94587     }
94588   }
94589
94590   jresult = (void *)result;
94591   return jresult;
94592 }
94593
94594
94595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
94596   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94597
94598   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94599   {
94600     try {
94601       (*arg1)->DisableDomain();
94602     } catch (std::out_of_range& e) {
94603       {
94604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94605       };
94606     } catch (std::exception& e) {
94607       {
94608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94609       };
94610     } catch (Dali::DaliException e) {
94611       {
94612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94613       };
94614     } catch (...) {
94615       {
94616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94617       };
94618     }
94619   }
94620
94621 }
94622
94623
94624 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
94625   float jresult ;
94626   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94627   float arg2 ;
94628   float arg3 ;
94629   float arg4 ;
94630   float result;
94631
94632   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94633   arg2 = (float)jarg2;
94634   arg3 = (float)jarg3;
94635   arg4 = (float)jarg4;
94636   {
94637     try {
94638       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
94639     } catch (std::out_of_range& e) {
94640       {
94641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94642       };
94643     } catch (std::exception& e) {
94644       {
94645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94646       };
94647     } catch (Dali::DaliException e) {
94648       {
94649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94650       };
94651     } catch (...) {
94652       {
94653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94654       };
94655     }
94656   }
94657
94658   jresult = result;
94659   return jresult;
94660 }
94661
94662
94663 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
94664   float jresult ;
94665   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94666   float arg2 ;
94667   float arg3 ;
94668   float result;
94669
94670   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94671   arg2 = (float)jarg2;
94672   arg3 = (float)jarg3;
94673   {
94674     try {
94675       result = (float)(*arg1)->Clamp(arg2,arg3);
94676     } catch (std::out_of_range& e) {
94677       {
94678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94679       };
94680     } catch (std::exception& e) {
94681       {
94682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94683       };
94684     } catch (Dali::DaliException e) {
94685       {
94686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94687       };
94688     } catch (...) {
94689       {
94690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94691       };
94692     }
94693   }
94694
94695   jresult = result;
94696   return jresult;
94697 }
94698
94699
94700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
94701   float jresult ;
94702   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94703   float arg2 ;
94704   float result;
94705
94706   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94707   arg2 = (float)jarg2;
94708   {
94709     try {
94710       result = (float)(*arg1)->Clamp(arg2);
94711     } catch (std::out_of_range& e) {
94712       {
94713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94714       };
94715     } catch (std::exception& e) {
94716       {
94717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94718       };
94719     } catch (Dali::DaliException e) {
94720       {
94721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94722       };
94723     } catch (...) {
94724       {
94725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94726       };
94727     }
94728   }
94729
94730   jresult = result;
94731   return jresult;
94732 }
94733
94734
94735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
94736   float jresult ;
94737   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94738   float arg2 ;
94739   float arg3 ;
94740   float arg4 ;
94741   Dali::Toolkit::ClampState *arg5 = 0 ;
94742   float result;
94743
94744   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94745   arg2 = (float)jarg2;
94746   arg3 = (float)jarg3;
94747   arg4 = (float)jarg4;
94748   arg5 = (Dali::Toolkit::ClampState *)jarg5;
94749   if (!arg5) {
94750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
94751     return 0;
94752   }
94753   {
94754     try {
94755       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
94756     } catch (std::out_of_range& e) {
94757       {
94758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94759       };
94760     } catch (std::exception& e) {
94761       {
94762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94763       };
94764     } catch (Dali::DaliException e) {
94765       {
94766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94767       };
94768     } catch (...) {
94769       {
94770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94771       };
94772     }
94773   }
94774
94775   jresult = result;
94776   return jresult;
94777 }
94778
94779
94780 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
94781   float jresult ;
94782   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94783   float arg2 ;
94784   float arg3 ;
94785   float arg4 ;
94786   float arg5 ;
94787   float result;
94788
94789   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94790   arg2 = (float)jarg2;
94791   arg3 = (float)jarg3;
94792   arg4 = (float)jarg4;
94793   arg5 = (float)jarg5;
94794   {
94795     try {
94796       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
94797     } catch (std::out_of_range& e) {
94798       {
94799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94800       };
94801     } catch (std::exception& e) {
94802       {
94803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94804       };
94805     } catch (Dali::DaliException e) {
94806       {
94807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94808       };
94809     } catch (...) {
94810       {
94811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94812       };
94813     }
94814   }
94815
94816   jresult = result;
94817   return jresult;
94818 }
94819
94820
94821 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
94822   float jresult ;
94823   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94824   float arg2 ;
94825   float arg3 ;
94826   float arg4 ;
94827   float result;
94828
94829   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94830   arg2 = (float)jarg2;
94831   arg3 = (float)jarg3;
94832   arg4 = (float)jarg4;
94833   {
94834     try {
94835       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
94836     } catch (std::out_of_range& e) {
94837       {
94838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94839       };
94840     } catch (std::exception& e) {
94841       {
94842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94843       };
94844     } catch (Dali::DaliException e) {
94845       {
94846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94847       };
94848     } catch (...) {
94849       {
94850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94851       };
94852     }
94853   }
94854
94855   jresult = result;
94856   return jresult;
94857 }
94858
94859
94860 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
94861   float jresult ;
94862   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94863   float arg2 ;
94864   float arg3 ;
94865   float result;
94866
94867   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94868   arg2 = (float)jarg2;
94869   arg3 = (float)jarg3;
94870   {
94871     try {
94872       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
94873     } catch (std::out_of_range& e) {
94874       {
94875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94876       };
94877     } catch (std::exception& e) {
94878       {
94879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94880       };
94881     } catch (Dali::DaliException e) {
94882       {
94883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94884       };
94885     } catch (...) {
94886       {
94887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94888       };
94889     }
94890   }
94891
94892   jresult = result;
94893   return jresult;
94894 }
94895
94896
94897 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
94898   float jresult ;
94899   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94900   float arg2 ;
94901   float result;
94902
94903   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94904   arg2 = (float)jarg2;
94905   {
94906     try {
94907       result = (float)(*arg1)->SnapAndClamp(arg2);
94908     } catch (std::out_of_range& e) {
94909       {
94910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94911       };
94912     } catch (std::exception& e) {
94913       {
94914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94915       };
94916     } catch (Dali::DaliException e) {
94917       {
94918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94919       };
94920     } catch (...) {
94921       {
94922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94923       };
94924     }
94925   }
94926
94927   jresult = result;
94928   return jresult;
94929 }
94930
94931
94932 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
94933   float jresult ;
94934   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94935   float arg2 ;
94936   float arg3 ;
94937   float arg4 ;
94938   float arg5 ;
94939   Dali::Toolkit::ClampState *arg6 = 0 ;
94940   float result;
94941
94942   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94943   arg2 = (float)jarg2;
94944   arg3 = (float)jarg3;
94945   arg4 = (float)jarg4;
94946   arg5 = (float)jarg5;
94947   arg6 = (Dali::Toolkit::ClampState *)jarg6;
94948   if (!arg6) {
94949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
94950     return 0;
94951   }
94952   {
94953     try {
94954       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
94955     } catch (std::out_of_range& e) {
94956       {
94957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94958       };
94959     } catch (std::exception& e) {
94960       {
94961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94962       };
94963     } catch (Dali::DaliException e) {
94964       {
94965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94966       };
94967     } catch (...) {
94968       {
94969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94970       };
94971     }
94972   }
94973
94974   jresult = result;
94975   return jresult;
94976 }
94977
94978
94979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
94980   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94981
94982   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94983   {
94984     try {
94985       (*arg1)->Reference();
94986     } catch (std::out_of_range& e) {
94987       {
94988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94989       };
94990     } catch (std::exception& e) {
94991       {
94992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94993       };
94994     } catch (Dali::DaliException e) {
94995       {
94996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94997       };
94998     } catch (...) {
94999       {
95000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95001       };
95002     }
95003   }
95004
95005 }
95006
95007
95008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
95009   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95010
95011   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95012   {
95013     try {
95014       (*arg1)->Unreference();
95015     } catch (std::out_of_range& e) {
95016       {
95017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95018       };
95019     } catch (std::exception& e) {
95020       {
95021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95022       };
95023     } catch (Dali::DaliException e) {
95024       {
95025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95026       };
95027     } catch (...) {
95028       {
95029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95030       };
95031     }
95032   }
95033
95034 }
95035
95036
95037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
95038   int jresult ;
95039   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95040   int result;
95041
95042   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95043   {
95044     try {
95045       result = (int)(*arg1)->ReferenceCount();
95046     } catch (std::out_of_range& e) {
95047       {
95048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95049       };
95050     } catch (std::exception& e) {
95051       {
95052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95053       };
95054     } catch (Dali::DaliException e) {
95055       {
95056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95057       };
95058     } catch (...) {
95059       {
95060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95061       };
95062     }
95063   }
95064
95065   jresult = result;
95066   return jresult;
95067 }
95068
95069
95070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
95071   unsigned int jresult ;
95072   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95073   bool result;
95074
95075   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95076   {
95077     try {
95078       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95079     } catch (std::out_of_range& e) {
95080       {
95081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95082       };
95083     } catch (std::exception& e) {
95084       {
95085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95086       };
95087     } catch (Dali::DaliException e) {
95088       {
95089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95090       };
95091     } catch (...) {
95092       {
95093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95094       };
95095     }
95096   }
95097
95098   jresult = result;
95099   return jresult;
95100 }
95101
95102
95103 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
95104   unsigned long jresult ;
95105   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95106   std::size_t result;
95107
95108   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95109   {
95110     try {
95111       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95112     } catch (std::out_of_range& e) {
95113       {
95114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95115       };
95116     } catch (std::exception& e) {
95117       {
95118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95119       };
95120     } catch (Dali::DaliException e) {
95121       {
95122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95123       };
95124     } catch (...) {
95125       {
95126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95127       };
95128     }
95129   }
95130
95131   jresult = (unsigned long)result;
95132   return jresult;
95133 }
95134
95135
95136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
95137   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95138   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95139
95140   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95141   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95142   {
95143     try {
95144       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
95145     } catch (std::out_of_range& e) {
95146       {
95147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95148       };
95149     } catch (std::exception& e) {
95150       {
95151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95152       };
95153     } catch (Dali::DaliException e) {
95154       {
95155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95156       };
95157     } catch (...) {
95158       {
95159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95160       };
95161     }
95162   }
95163
95164 }
95165
95166
95167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
95168   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95169   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95170
95171   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95172   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95173   {
95174     try {
95175       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
95176     } catch (std::out_of_range& e) {
95177       {
95178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95179       };
95180     } catch (std::exception& e) {
95181       {
95182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95183       };
95184     } catch (Dali::DaliException e) {
95185       {
95186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95187       };
95188     } catch (...) {
95189       {
95190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95191       };
95192     }
95193   }
95194
95195 }
95196
95197
95198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
95199   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95200   Dali::Toolkit::Control arg2 ;
95201   Dali::Toolkit::Control *argp2 ;
95202
95203   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95204   argp2 = (Dali::Toolkit::Control *)jarg2;
95205   if (!argp2) {
95206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
95207     return ;
95208   }
95209   arg2 = *argp2;
95210   {
95211     try {
95212       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
95213     } catch (std::out_of_range& e) {
95214       {
95215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95216       };
95217     } catch (std::exception& e) {
95218       {
95219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95220       };
95221     } catch (Dali::DaliException e) {
95222       {
95223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95224       };
95225     } catch (...) {
95226       {
95227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95228       };
95229     }
95230   }
95231
95232 }
95233
95234
95235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
95236   void * jresult ;
95237   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
95238
95239   {
95240     try {
95241       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
95242     } catch (std::out_of_range& e) {
95243       {
95244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95245       };
95246     } catch (std::exception& e) {
95247       {
95248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95249       };
95250     } catch (Dali::DaliException e) {
95251       {
95252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95253       };
95254     } catch (...) {
95255       {
95256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95257       };
95258     }
95259   }
95260
95261   jresult = (void *)result;
95262   return jresult;
95263 }
95264
95265
95266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
95267   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95268
95269   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95270   {
95271     try {
95272       delete arg1;
95273     } catch (std::out_of_range& e) {
95274       {
95275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95276       };
95277     } catch (std::exception& e) {
95278       {
95279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95280       };
95281     } catch (Dali::DaliException e) {
95282       {
95283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95284       };
95285     } catch (...) {
95286       {
95287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95288       };
95289     }
95290   }
95291
95292 }
95293
95294 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
95295   Dali::RefObject *result = NULL;
95296
95297   if (arg1)
95298   {
95299     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
95300   }
95301   return result;
95302 }
95303
95304 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
95305     return (Dali::RefObject *)jarg1;
95306 }
95307
95308 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
95309     return (Dali::SignalObserver *)jarg1;
95310 }
95311
95312 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
95313     return (Dali::ConnectionTrackerInterface *)jarg1;
95314 }
95315
95316 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
95317     return (Dali::BaseHandle *)jarg1;
95318 }
95319
95320 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
95321     return (Dali::BaseHandle *)jarg1;
95322 }
95323
95324 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
95325     return (Dali::BaseHandle *)jarg1;
95326 }
95327
95328 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
95329     return (Dali::BaseHandle *)jarg1;
95330 }
95331
95332 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
95333     return (Dali::BaseHandle *)jarg1;
95334 }
95335
95336 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
95337     return (Dali::BaseHandle *)jarg1;
95338 }
95339
95340 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
95341     return (Dali::BaseHandle *)jarg1;
95342 }
95343
95344 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
95345     return (Dali::BaseHandle *)jarg1;
95346 }
95347
95348 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
95349     return (Dali::BaseHandle *)jarg1;
95350 }
95351
95352 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
95353     return (Dali::BaseHandle *)jarg1;
95354 }
95355
95356 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VertexBuffer_SWIGUpcast(Dali::VertexBuffer *jarg1) {
95357     return (Dali::BaseHandle *)jarg1;
95358 }
95359
95360 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
95361     return (Dali::BaseHandle *)jarg1;
95362 }
95363
95364 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
95365     return (Dali::Handle *)jarg1;
95366 }
95367
95368 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
95369     return (Dali::Handle *)jarg1;
95370 }
95371
95372 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
95373     return (Dali::BaseHandle *)jarg1;
95374 }
95375
95376 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
95377     return (Dali::BaseHandle *)jarg1;
95378 }
95379
95380 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
95381     return (Dali::Handle *)jarg1;
95382 }
95383
95384 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchEvent *jarg1) {
95385     return (Dali::BaseHandle *)jarg1;
95386 }
95387
95388 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Hover_SWIGUpcast(Dali::HoverEvent *jarg1) {
95389     return (Dali::BaseHandle *)jarg1;
95390 }
95391
95392 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
95393     return (Dali::Handle *)jarg1;
95394 }
95395
95396 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
95397     return (Dali::GestureDetector *)jarg1;
95398 }
95399
95400 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
95401     return (Dali::Gesture *)jarg1;
95402 }
95403
95404 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
95405     return (Dali::Handle *)jarg1;
95406 }
95407
95408 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
95409     return (Dali::Actor *)jarg1;
95410 }
95411
95412 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
95413     return (Dali::RefObject *)jarg1;
95414 }
95415
95416 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
95417     return (Dali::Actor *)jarg1;
95418 }
95419
95420 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
95421     return (Dali::GestureDetector *)jarg1;
95422 }
95423
95424 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
95425     return (Dali::Gesture *)jarg1;
95426 }
95427
95428 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
95429     return (Dali::GestureDetector *)jarg1;
95430 }
95431
95432 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
95433     return (Dali::Gesture *)jarg1;
95434 }
95435
95436 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
95437     return (Dali::GestureDetector *)jarg1;
95438 }
95439
95440 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
95441     return (Dali::Gesture *)jarg1;
95442 }
95443
95444 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
95445     return (Dali::BaseHandle *)jarg1;
95446 }
95447
95448 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
95449     return (Dali::Handle *)jarg1;
95450 }
95451
95452 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
95453     return (Dali::Handle *)jarg1;
95454 }
95455
95456 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
95457     return (Dali::Handle *)jarg1;
95458 }
95459
95460 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
95461     return (Dali::RefObject *)jarg1;
95462 }
95463
95464 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
95465     return (Dali::Actor *)jarg1;
95466 }
95467
95468 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
95469     return (Dali::BaseHandle *)jarg1;
95470 }
95471
95472 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
95473     return (Dali::BaseHandle *)jarg1;
95474 }
95475
95476 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
95477     return (Dali::BaseHandle *)jarg1;
95478 }
95479
95480 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
95481     return (Dali::CustomActorImpl *)jarg1;
95482 }
95483
95484 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
95485     return (Dali::CustomActor *)jarg1;
95486 }
95487
95488 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
95489     return (Dali::BaseHandle *)jarg1;
95490 }
95491
95492 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
95493     return (Dali::Toolkit::Control *)jarg1;
95494 }
95495
95496 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
95497     return (Dali::Toolkit::Control *)jarg1;
95498 }
95499
95500 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
95501     return (Dali::Toolkit::Button *)jarg1;
95502 }
95503
95504 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
95505     return (Dali::Toolkit::Button *)jarg1;
95506 }
95507
95508 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
95509     return (Dali::Toolkit::Button *)jarg1;
95510 }
95511
95512 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
95513     return (Dali::Toolkit::Control *)jarg1;
95514 }
95515
95516 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
95517     return (Dali::Toolkit::Control *)jarg1;
95518 }
95519
95520 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
95521     return (Dali::Toolkit::Control *)jarg1;
95522 }
95523
95524 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
95525     return (Dali::Toolkit::Control *)jarg1;
95526 }
95527
95528 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
95529     return (Dali::Toolkit::Control *)jarg1;
95530 }
95531
95532 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
95533     return (Dali::RefObject *)jarg1;
95534 }
95535
95536 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
95537     return (Dali::Toolkit::Scrollable *)jarg1;
95538 }
95539
95540 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
95541     return (Dali::BaseHandle *)jarg1;
95542 }
95543
95544 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
95545     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
95546 }
95547
95548 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
95549     return (Dali::RefObject *)jarg1;
95550 }
95551
95552 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
95553     return (Dali::Toolkit::Ruler *)jarg1;
95554 }
95555
95556 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
95557     return (Dali::Toolkit::Ruler *)jarg1;
95558 }
95559
95560 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
95561     return (Dali::Toolkit::Scrollable *)jarg1;
95562 }
95563
95564 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
95565     return (Dali::Toolkit::Control *)jarg1;
95566 }
95567
95568
95569 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
95570     return (Dali::Toolkit::Control *)jarg1;
95571 }
95572
95573 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
95574     return (Dali::BaseHandle *)jarg1;
95575 }
95576
95577 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
95578     return (Dali::BaseHandle *)jarg1;
95579 }
95580
95581 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
95582     return (Dali::Toolkit::Control *)jarg1;
95583 }
95584
95585 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
95586     return (Dali::Toolkit::Control *)jarg1;
95587 }
95588
95589 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
95590     return (Dali::Toolkit::Control *)jarg1;
95591 }
95592
95593 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
95594     return (Dali::Toolkit::Control *)jarg1;
95595 }
95596
95597 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
95598     return (Dali::Toolkit::Control *)jarg1;
95599 }
95600
95601 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
95602     return (Dali::Toolkit::Control *)jarg1;
95603 }
95604
95605 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
95606     return (Dali::Toolkit::PageTurnView *)jarg1;
95607 }
95608
95609 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
95610     return (Dali::Toolkit::PageTurnView *)jarg1;
95611 }
95612
95613 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
95614     return (Dali::Toolkit::Button *)jarg1;
95615 }
95616
95617 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
95618     return (Dali::BaseHandle *)jarg1;
95619 }
95620
95621 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
95622     return (Dali::BaseHandle *)jarg1;
95623 }
95624
95625 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
95626     return (Dali::BaseHandle *)jarg1;
95627 }
95628
95629 /*
95630  * Widget binding
95631  */
95632 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
95633     return (Dali::BaseHandle *)jarg1;
95634 }
95635
95636 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
95637     return (Dali::BaseObject *)jarg1;
95638 }
95639
95640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
95641   void * jresult ;
95642   Dali::Widget result;
95643
95644   {
95645     try {
95646       result = Dali::Widget::New();
95647     } catch (std::out_of_range& e) {
95648       {
95649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95650       };
95651     } catch (std::exception& e) {
95652       {
95653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95654       };
95655     } catch (...) {
95656       {
95657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95658       };
95659     }
95660   }
95661   jresult = new Dali::Widget((const Dali::Widget &)result);
95662   return jresult;
95663 }
95664
95665
95666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
95667   void * jresult ;
95668   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
95669   Dali::Widget result;
95670
95671   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95672
95673   if (!arg1) {
95674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
95675     return 0;
95676   }
95677   {
95678     try {
95679       jresult = new Dali::Widget(arg1);
95680     } catch (std::out_of_range& e) {
95681       {
95682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95683       };
95684     } catch (std::exception& e) {
95685       {
95686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95687       };
95688     } catch (...) {
95689       {
95690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95691       };
95692     }
95693   }
95694   return jresult;
95695 }
95696
95697
95698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
95699   void * jresult ;
95700   Dali::Widget *result = 0 ;
95701
95702   {
95703     try {
95704       result = (Dali::Widget *)new Dali::Widget();
95705     } catch (std::out_of_range& e) {
95706       {
95707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95708       };
95709     } catch (std::exception& e) {
95710       {
95711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95712       };
95713     } catch (...) {
95714       {
95715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95716       };
95717     }
95718   }
95719   jresult = (void *)result;
95720   return jresult;
95721 }
95722
95723
95724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
95725   void * jresult ;
95726   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
95727   Dali::Widget *arg2 = 0 ;
95728   Dali::Widget *result = 0 ;
95729
95730   arg1 = (Dali::Widget *)jarg1;
95731   arg2 = (Dali::Widget *)jarg2;
95732   if (!arg2) {
95733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
95734     return 0;
95735   }
95736   {
95737     try {
95738       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
95739     } catch (std::out_of_range& e) {
95740       {
95741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95742       };
95743     } catch (std::exception& e) {
95744       {
95745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95746       };
95747     } catch (...) {
95748       {
95749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95750       };
95751     }
95752   }
95753   jresult = (void *)result;
95754   return jresult;
95755 }
95756
95757
95758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
95759   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
95760
95761   arg1 = (Dali::Widget *)jarg1;
95762   {
95763     try {
95764       delete arg1;
95765     } catch (std::out_of_range& e) {
95766       {
95767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95768       };
95769     } catch (std::exception& e) {
95770       {
95771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95772       };
95773     } catch (...) {
95774       {
95775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95776       };
95777     }
95778   }
95779 }
95780
95781
95782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
95783   void * jresult ;
95784   SwigDirector_WidgetImpl* result;
95785   {
95786     try {
95787       result = new SwigDirector_WidgetImpl();
95788     } catch (std::out_of_range& e) {
95789       {
95790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95791       };
95792     } catch (std::exception& e) {
95793       {
95794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95795       };
95796     } catch (...) {
95797       {
95798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95799       };
95800     }
95801   }
95802   jresult = result;
95803   return jresult;
95804 }
95805
95806
95807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
95808   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95809   std::string *arg2 = 0 ;
95810   Dali::Window arg3 ;
95811   Dali::Window *argp3 ;
95812
95813   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95814   if (!jarg2) {
95815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95816     return ;
95817   }
95818   std::string arg2_str(jarg2);
95819   arg2 = &arg2_str;
95820   argp3 = (Dali::Window *)jarg3;
95821   if (!argp3) {
95822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95823     return ;
95824   }
95825   arg3 = *argp3;
95826   {
95827     try {
95828       (arg1)->OnCreate((std::string const &)*arg2,arg3);
95829     } catch (std::out_of_range& e) {
95830       {
95831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95832       };
95833     } catch (std::exception& e) {
95834       {
95835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95836       };
95837     } catch (...) {
95838       {
95839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95840       };
95841     }
95842   }
95843 }
95844
95845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
95846   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95847   std::string *arg2 = 0 ;
95848   Dali::Window arg3 ;
95849   Dali::Window *argp3 ;
95850
95851   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95852   if (!jarg2) {
95853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95854     return ;
95855   }
95856   std::string arg2_str(jarg2);
95857   arg2 = &arg2_str;
95858   argp3 = (Dali::Window *)jarg3;
95859   if (!argp3) {
95860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95861     return ;
95862   }
95863   arg3 = *argp3;
95864   {
95865     try {
95866       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
95867     } catch (std::out_of_range& e) {
95868       {
95869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95870       };
95871     } catch (std::exception& e) {
95872       {
95873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95874       };
95875     } catch (...) {
95876       {
95877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95878       };
95879     }
95880   }
95881 }
95882
95883
95884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
95885   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95886   std::string *arg2 = 0 ;
95887   Dali::Widget::Termination arg3 ;
95888
95889   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95890   if (!jarg2) {
95891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95892     return ;
95893   }
95894   std::string arg2_str(jarg2);
95895   arg2 = &arg2_str;
95896   arg3 = (Dali::Widget::Termination)jarg3;
95897   {
95898     try {
95899       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
95900     } catch (std::out_of_range& e) {
95901       {
95902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95903       };
95904     } catch (std::exception& e) {
95905       {
95906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95907       };
95908     } catch (...) {
95909       {
95910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95911       };
95912     }
95913   }
95914 }
95915
95916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
95917   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95918   std::string *arg2 = 0 ;
95919   Dali::Widget::Termination arg3 ;
95920
95921   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95922   if (!jarg2) {
95923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95924     return ;
95925   }
95926   std::string arg2_str(jarg2);
95927   arg2 = &arg2_str;
95928   arg3 = (Dali::Widget::Termination)jarg3;
95929   {
95930     try {
95931       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
95932     } catch (std::out_of_range& e) {
95933       {
95934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95935       };
95936     } catch (std::exception& e) {
95937       {
95938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95939       };
95940     } catch (...) {
95941       {
95942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95943       };
95944     }
95945   }
95946 }
95947
95948
95949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
95950   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95951
95952   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95953   {
95954     try {
95955       (arg1)->OnPause();
95956     } catch (std::out_of_range& e) {
95957       {
95958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95959       };
95960     } catch (std::exception& e) {
95961       {
95962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95963       };
95964     } catch (...) {
95965       {
95966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95967       };
95968     }
95969   }
95970 }
95971
95972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
95973   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95974
95975   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95976   {
95977     try {
95978       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
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_OnResume(void * jarg1) {
95997   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95998
95999   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96000   {
96001     try {
96002       (arg1)->OnResume();
96003     } catch (std::out_of_range& e) {
96004       {
96005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96006       };
96007     } catch (std::exception& e) {
96008       {
96009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96010       };
96011     } catch (...) {
96012       {
96013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96014       };
96015     }
96016   }
96017 }
96018
96019
96020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
96021   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96022
96023   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96024   {
96025     try {
96026       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
96027     } catch (std::out_of_range& e) {
96028       {
96029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96030       };
96031     } catch (std::exception& e) {
96032       {
96033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96034       };
96035     } catch (...) {
96036       {
96037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96038       };
96039     }
96040   }
96041 }
96042
96043
96044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
96045   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96046   Dali::Window arg2 ;
96047   Dali::Window *argp2 ;
96048
96049   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96050   argp2 = (Dali::Window *)jarg2;
96051   if (!argp2) {
96052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96053     return ;
96054   }
96055   arg2 = *argp2;
96056   {
96057     try {
96058       (arg1)->OnResize(arg2);
96059     } catch (std::out_of_range& e) {
96060       {
96061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96062       };
96063     } catch (std::exception& e) {
96064       {
96065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96066       };
96067     } catch (...) {
96068       {
96069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96070       };
96071     }
96072   }
96073 }
96074
96075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
96076   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96077   Dali::Window arg2 ;
96078   Dali::Window *argp2 ;
96079
96080   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96081   argp2 = (Dali::Window *)jarg2;
96082   if (!argp2) {
96083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96084     return ;
96085   }
96086   arg2 = *argp2;
96087   {
96088     try {
96089       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
96090     } catch (std::out_of_range& e) {
96091       {
96092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96093       };
96094     } catch (std::exception& e) {
96095       {
96096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96097       };
96098     } catch (...) {
96099       {
96100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96101       };
96102     }
96103   }
96104 }
96105
96106
96107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
96108   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96109   std::string *arg2 = 0 ;
96110   int arg3 ;
96111
96112   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96113   if (!jarg2) {
96114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96115     return ;
96116   }
96117   std::string arg2_str(jarg2);
96118   arg2 = &arg2_str;
96119   arg3 = (int)jarg3;
96120   {
96121     try {
96122       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
96123     } catch (std::out_of_range& e) {
96124       {
96125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96126       };
96127     } catch (std::exception& e) {
96128       {
96129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96130       };
96131     } catch (...) {
96132       {
96133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96134       };
96135     }
96136   }
96137 }
96138
96139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96140   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96141   std::string *arg2 = 0 ;
96142   int arg3 ;
96143
96144   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96145   if (!jarg2) {
96146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96147     return ;
96148   }
96149   std::string arg2_str(jarg2);
96150   arg2 = &arg2_str;
96151   arg3 = (int)jarg3;
96152   {
96153     try {
96154       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
96155     } catch (std::out_of_range& e) {
96156       {
96157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96158       };
96159     } catch (std::exception& e) {
96160       {
96161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96162       };
96163     } catch (...) {
96164       {
96165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96166       };
96167     }
96168   }
96169 }
96170
96171
96172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
96173   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96174   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96175   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96176
96177   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96178   arg2 = (Dali::SlotObserver *)jarg2;
96179   arg3 = (Dali::CallbackBase *)jarg3;
96180   {
96181     try {
96182       (arg1)->SignalConnected(arg2,arg3);
96183     } catch (std::out_of_range& e) {
96184       {
96185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96186       };
96187     } catch (std::exception& e) {
96188       {
96189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96190       };
96191     } catch (...) {
96192       {
96193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96194       };
96195     }
96196   }
96197 }
96198
96199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96200   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96201   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96202   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96203
96204   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96205   arg2 = (Dali::SlotObserver *)jarg2;
96206   arg3 = (Dali::CallbackBase *)jarg3;
96207   {
96208     try {
96209       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
96210     } catch (std::out_of_range& e) {
96211       {
96212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96213       };
96214     } catch (std::exception& e) {
96215       {
96216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96217       };
96218     } catch (...) {
96219       {
96220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96221       };
96222     }
96223   }
96224 }
96225
96226
96227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
96228   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96229   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96230   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96231
96232   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96233   arg2 = (Dali::SlotObserver *)jarg2;
96234   arg3 = (Dali::CallbackBase *)jarg3;
96235   {
96236     try {
96237       (arg1)->SignalDisconnected(arg2,arg3);
96238     } catch (std::out_of_range& e) {
96239       {
96240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96241       };
96242     } catch (std::exception& e) {
96243       {
96244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96245       };
96246     } catch (...) {
96247       {
96248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96249       };
96250     }
96251   }
96252 }
96253
96254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96255   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96256   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96257   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96258
96259   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96260   arg2 = (Dali::SlotObserver *)jarg2;
96261   arg3 = (Dali::CallbackBase *)jarg3;
96262   {
96263     try {
96264       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
96265     } catch (std::out_of_range& e) {
96266       {
96267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96268       };
96269     } catch (std::exception& e) {
96270       {
96271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96272       };
96273     } catch (...) {
96274       {
96275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96276       };
96277     }
96278   }
96279 }
96280
96281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
96282   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96283   std::string *arg2 = 0 ;
96284
96285   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96286   if (!jarg2) {
96287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96288     return ;
96289   }
96290   std::string arg2_str(jarg2);
96291   arg2 = &arg2_str;
96292   {
96293     try {
96294       (arg1)->SetContentInfo((std::string const &)*arg2);
96295     } catch (std::out_of_range& e) {
96296       {
96297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96298       };
96299     } catch (std::exception& e) {
96300       {
96301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96302       };
96303     } catch (...) {
96304       {
96305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96306       };
96307     }
96308   }
96309 }
96310
96311
96312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
96313   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96314   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
96315
96316   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96317   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
96318   {
96319     try {
96320       (arg1)->SetImpl(arg2);
96321     } catch (std::out_of_range& e) {
96322       {
96323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96324       };
96325     } catch (std::exception& e) {
96326       {
96327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96328       };
96329     } catch (...) {
96330       {
96331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96332       };
96333     }
96334   }
96335 }
96336
96337 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) {
96338
96339   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
96340   if (director) {
96341     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
96342   }
96343 }
96344
96345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
96346   void * jresult ;
96347   Dali::Widget *arg1 = 0 ;
96348   SwigDirector_WidgetImpl *result = 0 ;
96349
96350   arg1 = (Dali::Widget *)jarg1;
96351   if (!arg1) {
96352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
96353     return 0;
96354   }
96355   {
96356     try {
96357       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
96358     } catch (std::out_of_range& e) {
96359       {
96360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96361       };
96362     } catch (std::exception& e) {
96363       {
96364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96365       };
96366     } catch (...) {
96367       {
96368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96369       };
96370     }
96371   }
96372
96373   jresult = (void *)result;
96374   return jresult;
96375 }
96376
96377
96378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
96379   void * jresult ;
96380   int *arg1 = (int *) 0 ;
96381   char ***arg2 ;
96382   std::string *arg3 = 0 ;
96383   Dali::WidgetApplication result;
96384   {
96385     int index = 0;
96386     int length = 0;
96387     char *retPtr;
96388     char *nextPtr;
96389     argWidgetC = jarg1;
96390     argWidgetV = new char*[jarg1 + 1];
96391
96392     retPtr = strtok_r( jarg2, " ", &nextPtr);
96393     if( retPtr )
96394     {
96395       length = strlen(retPtr);
96396     }
96397     argWidgetV[index] = new char[length + 1];
96398     if( retPtr )
96399     {
96400       strncpy(argWidgetV[index], retPtr, length);
96401     }
96402     argWidgetV[index][length] = '\0';
96403     index++;
96404
96405     while (index < jarg1)
96406     {
96407       length = 0;
96408       retPtr = strtok_r(NULL, " ", &nextPtr);
96409       if( retPtr )
96410       {
96411         length = strlen(retPtr);
96412       }
96413       argWidgetV[index] = new char[length + 1];
96414       if( retPtr )
96415       {
96416         strncpy(argWidgetV[index], retPtr, length);
96417       }
96418       argWidgetV[index][length] = '\0';
96419       index++;
96420     }
96421
96422     argWidgetV[jarg1] = NULL;
96423     argWidgetC = jarg1;
96424
96425     arg1 = &argWidgetC;
96426     arg2 = &argWidgetV;
96427   }
96428
96429   if (!jarg3) {
96430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96431     return 0;
96432   }
96433   std::string arg3_str(jarg3);
96434   arg3 = &arg3_str;
96435   {
96436     try {
96437       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
96438     } catch (std::out_of_range& e) {
96439       {
96440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96441       };
96442     } catch (std::exception& e) {
96443       {
96444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96445       };
96446     } catch (...) {
96447       {
96448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96449       };
96450     }
96451   }
96452   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
96453
96454   return jresult;
96455 }
96456
96457
96458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
96459   void * jresult ;
96460   Dali::WidgetApplication *result = 0 ;
96461
96462   {
96463     try {
96464       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
96465     } catch (std::out_of_range& e) {
96466       {
96467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96468       };
96469     } catch (std::exception& e) {
96470       {
96471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96472       };
96473     } catch (...) {
96474       {
96475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96476       };
96477     }
96478   }
96479   jresult = (void *)result;
96480   return jresult;
96481 }
96482
96483
96484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
96485   void * jresult ;
96486   Dali::WidgetApplication *arg1 = 0 ;
96487   Dali::WidgetApplication *result = 0 ;
96488
96489   arg1 = (Dali::WidgetApplication *)jarg1;
96490   if (!arg1) {
96491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96492     return 0;
96493   }
96494   {
96495     try {
96496       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
96497     } catch (std::out_of_range& e) {
96498       {
96499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96500       };
96501     } catch (std::exception& e) {
96502       {
96503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96504       };
96505     } catch (...) {
96506       {
96507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96508       };
96509     }
96510   }
96511   jresult = (void *)result;
96512   return jresult;
96513 }
96514
96515
96516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
96517   void * jresult ;
96518   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96519   Dali::WidgetApplication *arg2 = 0 ;
96520   Dali::WidgetApplication *result = 0 ;
96521
96522   arg1 = (Dali::WidgetApplication *)jarg1;
96523   arg2 = (Dali::WidgetApplication *)jarg2;
96524   if (!arg2) {
96525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96526     return 0;
96527   }
96528   {
96529     try {
96530       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
96531     } catch (std::out_of_range& e) {
96532       {
96533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96534       };
96535     } catch (std::exception& e) {
96536       {
96537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96538       };
96539     } catch (...) {
96540       {
96541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96542       };
96543     }
96544   }
96545   jresult = (void *)result;
96546   return jresult;
96547 }
96548
96549
96550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
96551   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96552
96553   arg1 = (Dali::WidgetApplication *)jarg1;
96554   {
96555     try {
96556       delete arg1;
96557       if( argWidgetV )
96558       {
96559         // free string data
96560         for( int i=0; i < argWidgetC+1; i++)
96561         {
96562           delete [] argWidgetV[i];
96563         }
96564         delete [] argWidgetV;
96565       }
96566     } catch (std::out_of_range& e) {
96567       {
96568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96569       };
96570     } catch (std::exception& e) {
96571       {
96572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96573       };
96574     } catch (...) {
96575       {
96576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96577       };
96578     }
96579   }
96580 }
96581
96582
96583 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
96584 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
96585
96586 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
96587 {
96588   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
96589   return *widget;
96590 }
96591
96592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
96593   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96594   std::string *arg2 = 0 ;
96595
96596   arg1 = (Dali::WidgetApplication *)jarg1;
96597   if (!jarg2) {
96598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96599     return ;
96600   }
96601   std::string arg2_str(*jarg2);
96602   arg2 = &arg2_str;
96603
96604   if(!_CSharpCreateWidgetFunction)
96605   {
96606     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
96607   }
96608
96609   {
96610     try {
96611       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
96612     } catch (std::out_of_range& e) {
96613       {
96614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96615       };
96616     } catch (std::exception& e) {
96617       {
96618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96619       };
96620     } catch (...) {
96621       {
96622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96623       };
96624     }
96625   }
96626
96627   //Typemap argout in c++ file.
96628   //This will convert c++ string to c# string
96629   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
96630 }
96631
96632
96633 //for PixelBuffer and ImageLoading
96634
96635 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
96636     return (Dali::BaseHandle *)jarg1;
96637 }
96638
96639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
96640   void * jresult ;
96641   unsigned int arg1 ;
96642   unsigned int arg2 ;
96643   Dali::Pixel::Format arg3 ;
96644   Dali::Devel::PixelBuffer result;
96645
96646   arg1 = (unsigned int)jarg1;
96647   arg2 = (unsigned int)jarg2;
96648   arg3 = (Dali::Pixel::Format)jarg3;
96649   {
96650     try {
96651       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
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::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
96667   return jresult;
96668 }
96669
96670
96671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
96672   void * jresult ;
96673   Dali::Devel::PixelBuffer *result = 0 ;
96674
96675   {
96676     try {
96677       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
96678     } catch (std::out_of_range& e) {
96679       {
96680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96681       };
96682     } catch (std::exception& e) {
96683       {
96684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96685       };
96686     } catch (...) {
96687       {
96688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96689       };
96690     }
96691   }
96692   jresult = (void *)result;
96693   return jresult;
96694 }
96695
96696
96697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
96698   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96699
96700   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96701   {
96702     try {
96703       delete arg1;
96704     } catch (std::out_of_range& e) {
96705       {
96706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96707       };
96708     } catch (std::exception& e) {
96709       {
96710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96711       };
96712     } catch (...) {
96713       {
96714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96715       };
96716     }
96717   }
96718 }
96719
96720
96721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
96722   void * jresult ;
96723   Dali::Devel::PixelBuffer *arg1 = 0 ;
96724   Dali::Devel::PixelBuffer *result = 0 ;
96725
96726   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96727   if (!arg1) {
96728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
96729     return 0;
96730   }
96731   {
96732     try {
96733       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
96734     } catch (std::out_of_range& e) {
96735       {
96736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96737       };
96738     } catch (std::exception& e) {
96739       {
96740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96741       };
96742     } catch (...) {
96743       {
96744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96745       };
96746     }
96747   }
96748   jresult = (void *)result;
96749   return jresult;
96750 }
96751
96752
96753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
96754   void * jresult ;
96755   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96756   Dali::Devel::PixelBuffer *arg2 = 0 ;
96757   Dali::Devel::PixelBuffer *result = 0 ;
96758
96759   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96760   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
96761   if (!arg2) {
96762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
96763     return 0;
96764   }
96765   {
96766     try {
96767       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
96768     } catch (std::out_of_range& e) {
96769       {
96770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96771       };
96772     } catch (std::exception& e) {
96773       {
96774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96775       };
96776     } catch (...) {
96777       {
96778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96779       };
96780     }
96781   }
96782   jresult = (void *)result;
96783   return jresult;
96784 }
96785
96786
96787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
96788   void * jresult ;
96789   Dali::Devel::PixelBuffer *arg1 = 0 ;
96790   Dali::PixelData result;
96791
96792   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96793   if (!arg1) {
96794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
96795     return 0;
96796   }
96797   {
96798     try {
96799       result = Dali::Devel::PixelBuffer::Convert(*arg1);
96800     } catch (std::out_of_range& e) {
96801       {
96802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96803       };
96804     } catch (std::exception& e) {
96805       {
96806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96807       };
96808     } catch (...) {
96809       {
96810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96811       };
96812     }
96813   }
96814   jresult = new Dali::PixelData((const Dali::PixelData &)result);
96815   return jresult;
96816 }
96817
96818
96819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
96820   void * jresult ;
96821   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96822   Dali::PixelData result;
96823
96824   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96825   {
96826     try {
96827       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
96828     } catch (std::out_of_range& e) {
96829       {
96830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96831       };
96832     } catch (std::exception& e) {
96833       {
96834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96835       };
96836     } catch (...) {
96837       {
96838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96839       };
96840     }
96841   }
96842   jresult = new Dali::PixelData((const Dali::PixelData &)result);
96843   return jresult;
96844 }
96845
96846
96847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
96848   void * jresult ;
96849   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96850   unsigned char *result = 0 ;
96851
96852   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96853   {
96854     try {
96855       result = (unsigned char *)(arg1)->GetBuffer();
96856     } catch (std::out_of_range& e) {
96857       {
96858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96859       };
96860     } catch (std::exception& e) {
96861       {
96862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96863       };
96864     } catch (...) {
96865       {
96866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96867       };
96868     }
96869   }
96870   jresult = (void *)result;
96871   return jresult;
96872 }
96873
96874
96875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
96876   unsigned int jresult ;
96877   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96878   unsigned int result;
96879
96880   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96881   {
96882     try {
96883       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
96884     } catch (std::out_of_range& e) {
96885       {
96886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96887       };
96888     } catch (std::exception& e) {
96889       {
96890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96891       };
96892     } catch (...) {
96893       {
96894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96895       };
96896     }
96897   }
96898   jresult = result;
96899   return jresult;
96900 }
96901
96902
96903 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
96904   unsigned int jresult ;
96905   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96906   unsigned int result;
96907
96908   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96909   {
96910     try {
96911       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
96912     } catch (std::out_of_range& e) {
96913       {
96914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96915       };
96916     } catch (std::exception& e) {
96917       {
96918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96919       };
96920     } catch (...) {
96921       {
96922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96923       };
96924     }
96925   }
96926   jresult = result;
96927   return jresult;
96928 }
96929
96930
96931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
96932   int jresult ;
96933   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96934   Dali::Pixel::Format result;
96935
96936   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96937   {
96938     try {
96939       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
96940     } catch (std::out_of_range& e) {
96941       {
96942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96943       };
96944     } catch (std::exception& e) {
96945       {
96946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96947       };
96948     } catch (...) {
96949       {
96950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96951       };
96952     }
96953   }
96954   jresult = (int)result;
96955   return jresult;
96956 }
96957
96958
96959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
96960   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96961   Dali::Devel::PixelBuffer arg2 ;
96962   float arg3 ;
96963   bool arg4 ;
96964   Dali::Devel::PixelBuffer *argp2 ;
96965
96966   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96967   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
96968   if (!argp2) {
96969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
96970     return ;
96971   }
96972   arg2 = *argp2;
96973   arg3 = (float)jarg3;
96974   arg4 = jarg4 ? true : false;
96975   {
96976     try {
96977       (arg1)->ApplyMask(arg2,arg3,arg4);
96978     } catch (std::out_of_range& e) {
96979       {
96980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96981       };
96982     } catch (std::exception& e) {
96983       {
96984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96985       };
96986     } catch (...) {
96987       {
96988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96989       };
96990     }
96991   }
96992 }
96993
96994
96995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
96996   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96997   Dali::Devel::PixelBuffer arg2 ;
96998   float arg3 ;
96999   Dali::Devel::PixelBuffer *argp2 ;
97000
97001   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97002   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97003   if (!argp2) {
97004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97005     return ;
97006   }
97007   arg2 = *argp2;
97008   arg3 = (float)jarg3;
97009   {
97010     try {
97011       (arg1)->ApplyMask(arg2,arg3);
97012     } catch (std::out_of_range& e) {
97013       {
97014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97015       };
97016     } catch (std::exception& e) {
97017       {
97018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97019       };
97020     } catch (...) {
97021       {
97022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97023       };
97024     }
97025   }
97026 }
97027
97028
97029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
97030   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97031   Dali::Devel::PixelBuffer arg2 ;
97032   Dali::Devel::PixelBuffer *argp2 ;
97033
97034   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97035   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97036   if (!argp2) {
97037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97038     return ;
97039   }
97040   arg2 = *argp2;
97041   {
97042     try {
97043       (arg1)->ApplyMask(arg2);
97044     } catch (std::out_of_range& e) {
97045       {
97046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97047       };
97048     } catch (std::exception& e) {
97049       {
97050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97051       };
97052     } catch (...) {
97053       {
97054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97055       };
97056     }
97057   }
97058 }
97059
97060
97061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
97062   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97063   float arg2 ;
97064
97065   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97066   arg2 = (float)jarg2;
97067   {
97068     try {
97069       (arg1)->ApplyGaussianBlur(arg2);
97070     } catch (std::out_of_range& e) {
97071       {
97072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97073       };
97074     } catch (std::exception& e) {
97075       {
97076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97077       };
97078     } catch (...) {
97079       {
97080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97081       };
97082     }
97083   }
97084 }
97085
97086
97087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
97088   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97089   uint16_t arg2 ;
97090   uint16_t arg3 ;
97091   uint16_t arg4 ;
97092   uint16_t arg5 ;
97093
97094   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97095   arg2 = (uint16_t)jarg2;
97096   arg3 = (uint16_t)jarg3;
97097   arg4 = (uint16_t)jarg4;
97098   arg5 = (uint16_t)jarg5;
97099   {
97100     try {
97101       (arg1)->Crop(arg2,arg3,arg4,arg5);
97102     } catch (std::out_of_range& e) {
97103       {
97104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97105       };
97106     } catch (std::exception& e) {
97107       {
97108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97109       };
97110     } catch (...) {
97111       {
97112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97113       };
97114     }
97115   }
97116 }
97117
97118
97119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
97120   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97121   uint16_t arg2 ;
97122   uint16_t arg3 ;
97123
97124   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97125   arg2 = (uint16_t)jarg2;
97126   arg3 = (uint16_t)jarg3;
97127   {
97128     try {
97129       (arg1)->Resize(arg2,arg3);
97130     } catch (std::out_of_range& e) {
97131       {
97132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97133       };
97134     } catch (std::exception& e) {
97135       {
97136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97137       };
97138     } catch (...) {
97139       {
97140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97141       };
97142     }
97143   }
97144 }
97145
97146 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void * jarg2) {
97147   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97148   Dali::Degree * arg2 ;
97149
97150   bool result = false;
97151
97152   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97153   arg2 = (Dali::Degree *)jarg2;
97154   {
97155     try {
97156       result = (arg1)->Rotate(*arg2);
97157     } catch (std::out_of_range& e) {
97158       {
97159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
97160       };
97161     } catch (std::exception& e) {
97162       {
97163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
97164       };
97165     } catch (...) {
97166       {
97167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
97168       };
97169     }
97170   }
97171   return result;
97172 }
97173
97174
97175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97176   void * jresult ;
97177   std::string *arg1 = 0 ;
97178   Dali::ImageDimensions arg2 ;
97179   Dali::FittingMode::Type arg3 ;
97180   Dali::SamplingMode::Type arg4 ;
97181   bool arg5 ;
97182   Dali::ImageDimensions *argp2 ;
97183   Dali::Devel::PixelBuffer result;
97184
97185   if (!jarg1) {
97186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97187     return 0;
97188   }
97189   std::string arg1_str(jarg1);
97190   arg1 = &arg1_str;
97191   argp2 = (Dali::ImageDimensions *)jarg2;
97192   if (!argp2) {
97193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97194     return 0;
97195   }
97196   arg2 = *argp2;
97197   arg3 = (Dali::FittingMode::Type)jarg3;
97198   arg4 = (Dali::SamplingMode::Type)jarg4;
97199   arg5 = jarg5 ? true : false;
97200   {
97201     try {
97202       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97203     } catch (std::out_of_range& e) {
97204       {
97205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97206       };
97207     } catch (std::exception& e) {
97208       {
97209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97210       };
97211     } catch (...) {
97212       {
97213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97214       };
97215     }
97216   }
97217   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97218
97219   return jresult;
97220 }
97221
97222
97223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97224   void * jresult ;
97225   std::string *arg1 = 0 ;
97226   Dali::ImageDimensions arg2 ;
97227   Dali::FittingMode::Type arg3 ;
97228   Dali::SamplingMode::Type arg4 ;
97229   Dali::ImageDimensions *argp2 ;
97230   Dali::Devel::PixelBuffer result;
97231
97232   if (!jarg1) {
97233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97234     return 0;
97235   }
97236   std::string arg1_str(jarg1);
97237   arg1 = &arg1_str;
97238   argp2 = (Dali::ImageDimensions *)jarg2;
97239   if (!argp2) {
97240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97241     return 0;
97242   }
97243   arg2 = *argp2;
97244   arg3 = (Dali::FittingMode::Type)jarg3;
97245   arg4 = (Dali::SamplingMode::Type)jarg4;
97246   {
97247     try {
97248       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
97249     } catch (std::out_of_range& e) {
97250       {
97251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97252       };
97253     } catch (std::exception& e) {
97254       {
97255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97256       };
97257     } catch (...) {
97258       {
97259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97260       };
97261     }
97262   }
97263   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97264
97265   return jresult;
97266 }
97267
97268
97269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97270   void * jresult ;
97271   std::string *arg1 = 0 ;
97272   Dali::ImageDimensions arg2 ;
97273   Dali::FittingMode::Type arg3 ;
97274   Dali::ImageDimensions *argp2 ;
97275   Dali::Devel::PixelBuffer result;
97276
97277   if (!jarg1) {
97278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97279     return 0;
97280   }
97281   std::string arg1_str(jarg1);
97282   arg1 = &arg1_str;
97283   argp2 = (Dali::ImageDimensions *)jarg2;
97284   if (!argp2) {
97285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97286     return 0;
97287   }
97288   arg2 = *argp2;
97289   arg3 = (Dali::FittingMode::Type)jarg3;
97290   {
97291     try {
97292       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
97293     } catch (std::out_of_range& e) {
97294       {
97295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97296       };
97297     } catch (std::exception& e) {
97298       {
97299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97300       };
97301     } catch (...) {
97302       {
97303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97304       };
97305     }
97306   }
97307   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97308
97309   return jresult;
97310 }
97311
97312
97313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
97314   void * jresult ;
97315   std::string *arg1 = 0 ;
97316   Dali::ImageDimensions arg2 ;
97317   Dali::ImageDimensions *argp2 ;
97318   Dali::Devel::PixelBuffer result;
97319
97320   if (!jarg1) {
97321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97322     return 0;
97323   }
97324   std::string arg1_str(jarg1);
97325   arg1 = &arg1_str;
97326   argp2 = (Dali::ImageDimensions *)jarg2;
97327   if (!argp2) {
97328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97329     return 0;
97330   }
97331   arg2 = *argp2;
97332   {
97333     try {
97334       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
97335     } catch (std::out_of_range& e) {
97336       {
97337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97338       };
97339     } catch (std::exception& e) {
97340       {
97341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97342       };
97343     } catch (...) {
97344       {
97345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97346       };
97347     }
97348   }
97349   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97350
97351   return jresult;
97352 }
97353
97354
97355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
97356   void * jresult ;
97357   std::string *arg1 = 0 ;
97358   Dali::Devel::PixelBuffer result;
97359
97360   if (!jarg1) {
97361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97362     return 0;
97363   }
97364   std::string arg1_str(jarg1);
97365   arg1 = &arg1_str;
97366   {
97367     try {
97368       result = Dali::LoadImageFromFile((std::string const &)*arg1);
97369     } catch (std::out_of_range& e) {
97370       {
97371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97372       };
97373     } catch (std::exception& e) {
97374       {
97375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97376       };
97377     } catch (...) {
97378       {
97379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97380       };
97381     }
97382   }
97383   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97384
97385   return jresult;
97386 }
97387
97388
97389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97390   void * jresult ;
97391   std::string *arg1 = 0 ;
97392   Dali::ImageDimensions arg2 ;
97393   Dali::FittingMode::Type arg3 ;
97394   Dali::SamplingMode::Type arg4 ;
97395   bool arg5 ;
97396   Dali::ImageDimensions *argp2 ;
97397   Dali::ImageDimensions result;
97398
97399   if (!jarg1) {
97400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97401     return 0;
97402   }
97403   std::string arg1_str(jarg1);
97404   arg1 = &arg1_str;
97405   argp2 = (Dali::ImageDimensions *)jarg2;
97406   if (!argp2) {
97407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97408     return 0;
97409   }
97410   arg2 = *argp2;
97411   arg3 = (Dali::FittingMode::Type)jarg3;
97412   arg4 = (Dali::SamplingMode::Type)jarg4;
97413   arg5 = jarg5 ? true : false;
97414   {
97415     try {
97416       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97417     } catch (std::out_of_range& e) {
97418       {
97419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97420       };
97421     } catch (std::exception& e) {
97422       {
97423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97424       };
97425     } catch (...) {
97426       {
97427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97428       };
97429     }
97430   }
97431   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97432
97433   return jresult;
97434 }
97435
97436
97437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97438   void * jresult ;
97439   std::string *arg1 = 0 ;
97440   Dali::ImageDimensions arg2 ;
97441   Dali::FittingMode::Type arg3 ;
97442   Dali::SamplingMode::Type arg4 ;
97443   Dali::ImageDimensions *argp2 ;
97444   Dali::ImageDimensions result;
97445
97446   if (!jarg1) {
97447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97448     return 0;
97449   }
97450   std::string arg1_str(jarg1);
97451   arg1 = &arg1_str;
97452   argp2 = (Dali::ImageDimensions *)jarg2;
97453   if (!argp2) {
97454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97455     return 0;
97456   }
97457   arg2 = *argp2;
97458   arg3 = (Dali::FittingMode::Type)jarg3;
97459   arg4 = (Dali::SamplingMode::Type)jarg4;
97460   {
97461     try {
97462       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
97463     } catch (std::out_of_range& e) {
97464       {
97465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97466       };
97467     } catch (std::exception& e) {
97468       {
97469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97470       };
97471     } catch (...) {
97472       {
97473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97474       };
97475     }
97476   }
97477   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97478
97479   return jresult;
97480 }
97481
97482
97483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97484   void * jresult ;
97485   std::string *arg1 = 0 ;
97486   Dali::ImageDimensions arg2 ;
97487   Dali::FittingMode::Type arg3 ;
97488   Dali::ImageDimensions *argp2 ;
97489   Dali::ImageDimensions result;
97490
97491   if (!jarg1) {
97492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97493     return 0;
97494   }
97495   std::string arg1_str(jarg1);
97496   arg1 = &arg1_str;
97497   argp2 = (Dali::ImageDimensions *)jarg2;
97498   if (!argp2) {
97499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97500     return 0;
97501   }
97502   arg2 = *argp2;
97503   arg3 = (Dali::FittingMode::Type)jarg3;
97504   {
97505     try {
97506       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
97507     } catch (std::out_of_range& e) {
97508       {
97509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97510       };
97511     } catch (std::exception& e) {
97512       {
97513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97514       };
97515     } catch (...) {
97516       {
97517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97518       };
97519     }
97520   }
97521   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97522
97523   return jresult;
97524 }
97525
97526
97527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
97528   void * jresult ;
97529   std::string *arg1 = 0 ;
97530   Dali::ImageDimensions arg2 ;
97531   Dali::ImageDimensions *argp2 ;
97532   Dali::ImageDimensions result;
97533
97534   if (!jarg1) {
97535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97536     return 0;
97537   }
97538   std::string arg1_str(jarg1);
97539   arg1 = &arg1_str;
97540   argp2 = (Dali::ImageDimensions *)jarg2;
97541   if (!argp2) {
97542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97543     return 0;
97544   }
97545   arg2 = *argp2;
97546   {
97547     try {
97548       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
97549     } catch (std::out_of_range& e) {
97550       {
97551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97552       };
97553     } catch (std::exception& e) {
97554       {
97555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97556       };
97557     } catch (...) {
97558       {
97559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97560       };
97561     }
97562   }
97563   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97564
97565   return jresult;
97566 }
97567
97568
97569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
97570   void * jresult ;
97571   std::string *arg1 = 0 ;
97572   Dali::ImageDimensions result;
97573
97574   if (!jarg1) {
97575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97576     return 0;
97577   }
97578   std::string arg1_str(jarg1);
97579   arg1 = &arg1_str;
97580   {
97581     try {
97582       result = Dali::GetClosestImageSize((std::string const &)*arg1);
97583     } catch (std::out_of_range& e) {
97584       {
97585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97586       };
97587     } catch (std::exception& e) {
97588       {
97589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97590       };
97591     } catch (...) {
97592       {
97593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97594       };
97595     }
97596   }
97597   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97598
97599   return jresult;
97600 }
97601
97602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
97603   void * jresult ;
97604   std::string *arg1 = 0 ;
97605   Dali::ImageDimensions result;
97606
97607   if (!jarg1) {
97608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97609     return 0;
97610   }
97611   std::string arg1_str(jarg1);
97612   arg1 = &arg1_str;
97613   {
97614     try {
97615       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
97616     } catch (std::out_of_range& e) {
97617       {
97618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97619       };
97620     } catch (std::exception& e) {
97621       {
97622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97623       };
97624     } catch (...) {
97625       {
97626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97627       };
97628     }
97629   }
97630   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97631
97632   return jresult;
97633 }
97634
97635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97636   void * jresult ;
97637   std::string *arg1 = 0 ;
97638   Dali::ImageDimensions arg2 ;
97639   Dali::FittingMode::Type arg3 ;
97640   Dali::SamplingMode::Type arg4 ;
97641   bool arg5 ;
97642   Dali::ImageDimensions *argp2 ;
97643   Dali::Devel::PixelBuffer result;
97644
97645   if (!jarg1) {
97646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97647     return 0;
97648   }
97649   std::string arg1_str(jarg1);
97650   arg1 = &arg1_str;
97651   argp2 = (Dali::ImageDimensions *)jarg2;
97652   if (!argp2) {
97653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97654     return 0;
97655   }
97656   arg2 = *argp2;
97657   arg3 = (Dali::FittingMode::Type)jarg3;
97658   arg4 = (Dali::SamplingMode::Type)jarg4;
97659   arg5 = jarg5 ? true : false;
97660   {
97661     try {
97662       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97663     } catch (std::out_of_range& e) {
97664       {
97665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97666       };
97667     } catch (std::exception& e) {
97668       {
97669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97670       };
97671     } catch (...) {
97672       {
97673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97674       };
97675     }
97676   }
97677   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97678
97679   return jresult;
97680 }
97681
97682
97683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97684   void * jresult ;
97685   std::string *arg1 = 0 ;
97686   Dali::ImageDimensions arg2 ;
97687   Dali::FittingMode::Type arg3 ;
97688   Dali::SamplingMode::Type arg4 ;
97689   Dali::ImageDimensions *argp2 ;
97690   Dali::Devel::PixelBuffer result;
97691
97692   if (!jarg1) {
97693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97694     return 0;
97695   }
97696   std::string arg1_str(jarg1);
97697   arg1 = &arg1_str;
97698   argp2 = (Dali::ImageDimensions *)jarg2;
97699   if (!argp2) {
97700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97701     return 0;
97702   }
97703   arg2 = *argp2;
97704   arg3 = (Dali::FittingMode::Type)jarg3;
97705   arg4 = (Dali::SamplingMode::Type)jarg4;
97706   {
97707     try {
97708       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
97709     } catch (std::out_of_range& e) {
97710       {
97711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97712       };
97713     } catch (std::exception& e) {
97714       {
97715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97716       };
97717     } catch (...) {
97718       {
97719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97720       };
97721     }
97722   }
97723   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97724
97725   return jresult;
97726 }
97727
97728
97729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97730   void * jresult ;
97731   std::string *arg1 = 0 ;
97732   Dali::ImageDimensions arg2 ;
97733   Dali::FittingMode::Type arg3 ;
97734   Dali::ImageDimensions *argp2 ;
97735   Dali::Devel::PixelBuffer result;
97736
97737   if (!jarg1) {
97738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97739     return 0;
97740   }
97741   std::string arg1_str(jarg1);
97742   arg1 = &arg1_str;
97743   argp2 = (Dali::ImageDimensions *)jarg2;
97744   if (!argp2) {
97745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97746     return 0;
97747   }
97748   arg2 = *argp2;
97749   arg3 = (Dali::FittingMode::Type)jarg3;
97750   {
97751     try {
97752       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
97753     } catch (std::out_of_range& e) {
97754       {
97755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97756       };
97757     } catch (std::exception& e) {
97758       {
97759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97760       };
97761     } catch (...) {
97762       {
97763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97764       };
97765     }
97766   }
97767   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97768
97769   return jresult;
97770 }
97771
97772
97773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
97774   void * jresult ;
97775   std::string *arg1 = 0 ;
97776   Dali::ImageDimensions arg2 ;
97777   Dali::ImageDimensions *argp2 ;
97778   Dali::Devel::PixelBuffer result;
97779
97780   if (!jarg1) {
97781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97782     return 0;
97783   }
97784   std::string arg1_str(jarg1);
97785   arg1 = &arg1_str;
97786   argp2 = (Dali::ImageDimensions *)jarg2;
97787   if (!argp2) {
97788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97789     return 0;
97790   }
97791   arg2 = *argp2;
97792   {
97793     try {
97794       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
97795     } catch (std::out_of_range& e) {
97796       {
97797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97798       };
97799     } catch (std::exception& e) {
97800       {
97801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97802       };
97803     } catch (...) {
97804       {
97805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97806       };
97807     }
97808   }
97809   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97810
97811   return jresult;
97812 }
97813
97814
97815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
97816   void * jresult ;
97817   std::string *arg1 = 0 ;
97818   Dali::Devel::PixelBuffer result;
97819
97820   if (!jarg1) {
97821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97822     return 0;
97823   }
97824   std::string arg1_str(jarg1);
97825   arg1 = &arg1_str;
97826   {
97827     try {
97828       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
97829     } catch (std::out_of_range& e) {
97830       {
97831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97832       };
97833     } catch (std::exception& e) {
97834       {
97835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97836       };
97837     } catch (...) {
97838       {
97839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97840       };
97841     }
97842   }
97843   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97844
97845   return jresult;
97846 }
97847
97848
97849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
97850   void * jresult ;
97851   Dali::Toolkit::WebView result;
97852
97853   {
97854     try {
97855       result = Dali::Toolkit::WebView::New();
97856     } catch (std::out_of_range& e) {
97857       {
97858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97859       };
97860     } catch (std::exception& e) {
97861       {
97862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97863       };
97864     } catch (Dali::DaliException e) {
97865       {
97866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97867       };
97868     } catch (...) {
97869       {
97870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97871       };
97872     }
97873   }
97874   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
97875   return jresult;
97876 }
97877
97878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
97879   void * jresult ;
97880   Dali::Toolkit::WebView result;
97881
97882   std::string *arg1;
97883   std::string *arg2;
97884
97885   if (!jarg1) {
97886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
97887     return 0;
97888   }
97889   if (!jarg2) {
97890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
97891     return 0;
97892   }
97893
97894   std::string jarg1_str = std::string(jarg1);
97895   std::string jarg2_str = std::string(jarg2);
97896
97897   arg1 = &jarg1_str;
97898   arg2 = &jarg2_str;
97899
97900   {
97901     try {
97902       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
97903     } catch (std::out_of_range& e) {
97904       {
97905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97906       };
97907     } catch (std::exception& e) {
97908       {
97909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97910       };
97911     } catch (Dali::DaliException e) {
97912       {
97913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97914       };
97915     } catch (...) {
97916       {
97917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97918       };
97919     }
97920   }
97921   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
97922   return jresult;
97923 }
97924
97925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
97926   void * jresult ;
97927   Dali::Toolkit::WebView *arg1 = 0 ;
97928   Dali::Toolkit::WebView *result = 0 ;
97929
97930   arg1 = (Dali::Toolkit::WebView *)jarg1;
97931   if (!arg1) {
97932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
97933     return 0;
97934   }
97935   {
97936     try {
97937       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
97938     } catch (std::out_of_range& e) {
97939       {
97940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97941       };
97942     } catch (std::exception& e) {
97943       {
97944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97945       };
97946     } catch (Dali::DaliException e) {
97947       {
97948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97949       };
97950     } catch (...) {
97951       {
97952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97953       };
97954     }
97955   }
97956   jresult = (void *)result;
97957   return jresult;
97958 }
97959
97960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
97961   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
97962   arg1 = (Dali::Toolkit::WebView *)jarg1;
97963   {
97964     try {
97965       delete arg1;
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_Assign(void * jarg1, void * jarg2) {
97987   void * jresult ;
97988   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
97989   Dali::Toolkit::WebView *arg2 = 0 ;
97990   Dali::Toolkit::WebView *result = 0 ;
97991
97992   arg1 = (Dali::Toolkit::WebView *)jarg1;
97993   arg2 = (Dali::Toolkit::WebView *)jarg2;
97994   if (!arg2) {
97995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
97996     return 0;
97997   }
97998   {
97999     try {
98000       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
98001     } catch (std::out_of_range& e) {
98002       {
98003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98004       };
98005     } catch (std::exception& e) {
98006       {
98007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98008       };
98009     } catch (Dali::DaliException e) {
98010       {
98011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98012       };
98013     } catch (...) {
98014       {
98015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98016       };
98017     }
98018   }
98019   jresult = (void *)result;
98020   return jresult;
98021 }
98022
98023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
98024   void * jresult ;
98025   Dali::BaseHandle arg1 ;
98026   Dali::BaseHandle *argp1 ;
98027   Dali::Toolkit::WebView result;
98028
98029   argp1 = (Dali::BaseHandle *)jarg1;
98030   if (!argp1) {
98031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
98032     return 0;
98033   }
98034   arg1 = *argp1;
98035   {
98036     try {
98037       result = Dali::Toolkit::WebView::DownCast(arg1);
98038     } catch (std::out_of_range& e) {
98039       {
98040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98041       };
98042     } catch (std::exception& e) {
98043       {
98044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98045       };
98046     } catch (Dali::DaliException e) {
98047       {
98048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98049       };
98050     } catch (...) {
98051       {
98052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98053       };
98054     }
98055   }
98056   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98057   return jresult;
98058 }
98059
98060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
98061   return (int) Dali::Toolkit::WebView::Property::URL;
98062 }
98063
98064 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
98065   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
98066 }
98067
98068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
98069   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
98070 }
98071
98072 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
98073   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
98074 }
98075
98076 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
98077   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
98078 }
98079
98080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
98081   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
98082 }
98083
98084 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
98085   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
98086 }
98087
98088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
98089   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
98090 }
98091
98092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
98093   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98094   std::string *arg2;
98095
98096   arg1 = (Dali::Toolkit::WebView *)jarg1;
98097
98098   if (!jarg2) {
98099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98100     return;
98101   }
98102
98103   std::string jarg2str = std::string(jarg2);
98104   arg2 = &jarg2str;
98105   {
98106     try {
98107       (arg1)->LoadUrl((std::string const &)*arg2);
98108     } catch (std::out_of_range& e) {
98109       {
98110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98111       };
98112     } catch (std::exception& e) {
98113       {
98114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98115       };
98116     } catch (Dali::DaliException e) {
98117       {
98118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98119       };
98120     } catch (...) {
98121       {
98122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98123       };
98124     }
98125   }
98126 }
98127
98128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
98129   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98130   std::string *arg2;
98131
98132   arg1 = (Dali::Toolkit::WebView *)jarg1;
98133   if (!jarg2) {
98134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98135     return;
98136   }
98137   std::string jarg2str = std::string(jarg2);
98138   arg2 = &jarg2str;
98139   {
98140     try {
98141       (arg1)->LoadHTMLString((std::string const &)*arg2);
98142     } catch (std::out_of_range& e) {
98143       {
98144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98145       };
98146     } catch (std::exception& e) {
98147       {
98148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98149       };
98150     } catch (Dali::DaliException e) {
98151       {
98152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98153       };
98154     } catch (...) {
98155       {
98156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98157       };
98158     }
98159   }
98160 }
98161
98162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
98163   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98164
98165   arg1 = (Dali::Toolkit::WebView *)jarg1;
98166   {
98167     try {
98168       (arg1)->Reload();
98169     } catch (std::out_of_range& e) {
98170       {
98171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98172       };
98173     } catch (std::exception& e) {
98174       {
98175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98176       };
98177     } catch (Dali::DaliException e) {
98178       {
98179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98180       };
98181     } catch (...) {
98182       {
98183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98184       };
98185     }
98186   }
98187 }
98188
98189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
98190   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98191
98192   arg1 = (Dali::Toolkit::WebView *)jarg1;
98193   {
98194     try {
98195       (arg1)->StopLoading();
98196     } catch (std::out_of_range& e) {
98197       {
98198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98199       };
98200     } catch (std::exception& e) {
98201       {
98202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98203       };
98204     } catch (Dali::DaliException e) {
98205       {
98206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98207       };
98208     } catch (...) {
98209       {
98210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98211       };
98212     }
98213   }
98214 }
98215
98216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
98217   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98218
98219   arg1 = (Dali::Toolkit::WebView *)jarg1;
98220   {
98221     try {
98222       (arg1)->Suspend();
98223     } catch (std::out_of_range& e) {
98224       {
98225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98226       };
98227     } catch (std::exception& e) {
98228       {
98229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98230       };
98231     } catch (Dali::DaliException e) {
98232       {
98233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98234       };
98235     } catch (...) {
98236       {
98237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98238       };
98239     }
98240   }
98241 }
98242
98243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
98244   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98245
98246   arg1 = (Dali::Toolkit::WebView *)jarg1;
98247   {
98248     try {
98249       (arg1)->Resume();
98250     } catch (std::out_of_range& e) {
98251       {
98252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98253       };
98254     } catch (std::exception& e) {
98255       {
98256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98257       };
98258     } catch (Dali::DaliException e) {
98259       {
98260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98261       };
98262     } catch (...) {
98263       {
98264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98265       };
98266     }
98267   }
98268 }
98269
98270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
98271   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98272
98273   arg1 = (Dali::Toolkit::WebView *)jarg1;
98274   {
98275     try {
98276       (arg1)->GoBack();
98277     } catch (std::out_of_range& e) {
98278       {
98279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98280       };
98281     } catch (std::exception& e) {
98282       {
98283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98284       };
98285     } catch (Dali::DaliException e) {
98286       {
98287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98288       };
98289     } catch (...) {
98290       {
98291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98292       };
98293     }
98294   }
98295 }
98296
98297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
98298   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98299
98300   arg1 = (Dali::Toolkit::WebView *)jarg1;
98301   {
98302     try {
98303       (arg1)->GoForward();
98304     } catch (std::out_of_range& e) {
98305       {
98306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98307       };
98308     } catch (std::exception& e) {
98309       {
98310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98311       };
98312     } catch (Dali::DaliException e) {
98313       {
98314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98315       };
98316     } catch (...) {
98317       {
98318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98319       };
98320     }
98321   }
98322 }
98323
98324 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
98325   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98326   bool ret;
98327
98328   arg1 = (Dali::Toolkit::WebView *)jarg1;
98329   {
98330     try {
98331       ret = (arg1)->CanGoBack();
98332     } catch (std::out_of_range& e) {
98333       {
98334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98335       };
98336     } catch (std::exception& e) {
98337       {
98338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98339       };
98340     } catch (Dali::DaliException e) {
98341       {
98342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98343       };
98344     } catch (...) {
98345       {
98346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98347       };
98348     }
98349   }
98350   return ret;
98351 }
98352
98353 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
98354   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98355   bool ret;
98356
98357   arg1 = (Dali::Toolkit::WebView *)jarg1;
98358   {
98359     try {
98360       ret = (arg1)->CanGoForward();
98361     } catch (std::out_of_range& e) {
98362       {
98363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98364       };
98365     } catch (std::exception& e) {
98366       {
98367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98368       };
98369     } catch (Dali::DaliException e) {
98370       {
98371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98372       };
98373     } catch (...) {
98374       {
98375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98376       };
98377     }
98378   }
98379   return ret;
98380 }
98381
98382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
98383   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98384   std::string *arg2;
98385
98386   arg1 = (Dali::Toolkit::WebView *)jarg1;
98387   if (!jarg2) {
98388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98389     return;
98390   }
98391   std::string jarg2_str = std::string(jarg2);
98392   arg2 = &jarg2_str;
98393
98394   {
98395     try {
98396       if (jarg3) {
98397         void (*handler)(char*) = (void (*)(char*)) jarg3;
98398         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
98399           handler(SWIG_csharp_string_callback(result.c_str()));
98400         });
98401       } else {
98402         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
98403       }
98404     } catch (std::out_of_range& e) {
98405       {
98406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98407       };
98408     } catch (std::exception& e) {
98409       {
98410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98411       };
98412     } catch (Dali::DaliException e) {
98413       {
98414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98415       };
98416     } catch (...) {
98417       {
98418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98419       };
98420     }
98421   }
98422 }
98423
98424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
98425 {
98426   if (!jarg2) {
98427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98428     return;
98429   }
98430
98431   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98432   std::string exposedObjectName = jarg2;
98433   void (*handler)(char*) = (void (*)(char*)) jarg3;
98434
98435   {
98436     try {
98437       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
98438         handler(SWIG_csharp_string_callback(message.c_str()));
98439       });
98440     } catch (std::out_of_range& e) {
98441       {
98442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98443       };
98444     } catch (std::exception& e) {
98445       {
98446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98447       };
98448     } catch (Dali::DaliException e) {
98449       {
98450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98451       };
98452     } catch (...) {
98453       {
98454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98455       };
98456     }
98457   }
98458 }
98459
98460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
98461   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98462
98463   arg1 = (Dali::Toolkit::WebView *)jarg1;
98464   {
98465     try {
98466       (arg1)->ClearHistory();
98467     } catch (std::out_of_range& e) {
98468       {
98469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98470       };
98471     } catch (std::exception& e) {
98472       {
98473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98474       };
98475     } catch (Dali::DaliException e) {
98476       {
98477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98478       };
98479     } catch (...) {
98480       {
98481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98482       };
98483     }
98484   }
98485 }
98486
98487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
98488   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98489
98490   arg1 = (Dali::Toolkit::WebView *)jarg1;
98491   {
98492     try {
98493       (arg1)->ClearCache();
98494     } catch (std::out_of_range& e) {
98495       {
98496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98497       };
98498     } catch (std::exception& e) {
98499       {
98500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98501       };
98502     } catch (Dali::DaliException e) {
98503       {
98504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98505       };
98506     } catch (...) {
98507       {
98508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98509       };
98510     }
98511   }
98512 }
98513
98514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
98515   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98516
98517   arg1 = (Dali::Toolkit::WebView *)jarg1;
98518   {
98519     try {
98520       (arg1)->ClearCookies();
98521     } catch (std::out_of_range& e) {
98522       {
98523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98524       };
98525     } catch (std::exception& e) {
98526       {
98527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98528       };
98529     } catch (Dali::DaliException e) {
98530       {
98531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98532       };
98533     } catch (...) {
98534       {
98535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98536       };
98537     }
98538   }
98539 }
98540
98541 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
98542     return (Dali::Toolkit::Control *)jarg1;
98543 }
98544
98545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
98546   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98547   SignalConverter::WebViewPageLoadSignal* result = NULL;
98548   {
98549     try {
98550       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
98551     } catch (std::out_of_range& e) {
98552       {
98553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98554       };
98555     } catch (std::exception& e) {
98556       {
98557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98558       };
98559     } catch (Dali::DaliException e) {
98560       {
98561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98562       };
98563     } catch (...) {
98564       {
98565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98566       };
98567     }
98568   }
98569   return (void*) result;
98570 }
98571
98572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
98573   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98574   SignalConverter::WebViewPageLoadSignal* result = NULL;
98575   {
98576     try {
98577       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
98578     } catch (std::out_of_range& e) {
98579       {
98580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98581       };
98582     } catch (std::exception& e) {
98583       {
98584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98585       };
98586     } catch (Dali::DaliException e) {
98587       {
98588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98589       };
98590     } catch (...) {
98591       {
98592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98593       };
98594     }
98595   }
98596   return (void*) result;
98597 }
98598
98599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
98600 {
98601   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98602   {
98603     try {
98604       delete object;
98605     } catch (std::out_of_range& e) {
98606       {
98607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98608       };
98609     } catch (std::exception& e) {
98610       {
98611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98612       };
98613     } catch (Dali::DaliException e) {
98614       {
98615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98616       };
98617     } catch (...) {
98618       {
98619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98620       };
98621     }
98622   }
98623 }
98624
98625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
98626 {
98627   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98628   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98629   {
98630     try {
98631       proxy->Connect(callback);
98632     } catch (std::out_of_range& e) {
98633       {
98634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98635       };
98636     } catch (std::exception& e) {
98637       {
98638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98639       };
98640     } catch (Dali::DaliException e) {
98641       {
98642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98643       };
98644     } catch (...) {
98645       {
98646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98647       };
98648     }
98649   }
98650 }
98651
98652
98653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
98654   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98655   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98656   {
98657     try {
98658       proxy->Disconnect(callback);
98659     } catch (std::out_of_range& e) {
98660       {
98661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98662       };
98663     } catch (std::exception& e) {
98664       {
98665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98666       };
98667     } catch (Dali::DaliException e) {
98668       {
98669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98670       };
98671     } catch (...) {
98672       {
98673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98674       };
98675     }
98676   }
98677 }
98678
98679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
98680   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98681   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
98682   {
98683     try {
98684       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
98685     } catch (std::out_of_range& e) {
98686       {
98687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98688       };
98689     } catch (std::exception& e) {
98690       {
98691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98692       };
98693     } catch (Dali::DaliException e) {
98694       {
98695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98696       };
98697     } catch (...) {
98698       {
98699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98700       };
98701     }
98702   }
98703   return (void*) result;
98704 }
98705
98706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
98707 {
98708   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98709   {
98710     try {
98711       delete object;
98712     } catch (std::out_of_range& e) {
98713       {
98714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98715       };
98716     } catch (std::exception& e) {
98717       {
98718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98719       };
98720     } catch (Dali::DaliException e) {
98721       {
98722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98723       };
98724     } catch (...) {
98725       {
98726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98727       };
98728     }
98729   }
98730 }
98731
98732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
98733 {
98734   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98735   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
98736   {
98737     try {
98738       proxy->Connect(callback);
98739     } catch (std::out_of_range& e) {
98740       {
98741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98742       };
98743     } catch (std::exception& e) {
98744       {
98745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98746       };
98747     } catch (Dali::DaliException e) {
98748       {
98749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98750       };
98751     } catch (...) {
98752       {
98753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98754       };
98755     }
98756   }
98757 }
98758
98759
98760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
98761   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98762   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
98763   {
98764     try {
98765       proxy->Disconnect(callback);
98766     } catch (std::out_of_range& e) {
98767       {
98768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98769       };
98770     } catch (std::exception& e) {
98771       {
98772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98773       };
98774     } catch (Dali::DaliException e) {
98775       {
98776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98777       };
98778     } catch (...) {
98779       {
98780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98781       };
98782     }
98783   }
98784 }
98785
98786 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
98787   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
98788   char * jresult = SWIG_csharp_string_callback((const char *)result);
98789   return jresult;
98790 }
98791
98792 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
98793   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
98794   return result;
98795 }
98796
98797
98798 struct NativeImageSourcePtrHandle
98799 {
98800   NativeImageSourcePtr Ptr;
98801 };
98802
98803 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
98804 {
98805   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98806   return (NativeImageInterface*)(arg1);
98807 }
98808
98809 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
98810 {
98811   void* jresult;
98812   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
98813   {
98814     try {
98815       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
98816     }
98817     catch (std::out_of_range & e) {
98818       {
98819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98820       };
98821     }
98822     catch (std::exception & e) {
98823       {
98824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98825       };
98826     }
98827     catch (Dali::DaliException e) {
98828       {
98829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98830       };
98831     }
98832     catch (...) {
98833       {
98834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98835       };
98836     }
98837   }
98838   jresult = (void *)handle;
98839   return jresult;
98840 }
98841
98842 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
98843 {
98844   void* jresult;
98845   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
98846   jresult = (void*)( handle->Ptr.Get() );
98847   return jresult;
98848 }
98849
98850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
98851   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
98852   {
98853     try {
98854       delete arg1;
98855     }
98856     catch (std::out_of_range & e) {
98857       {
98858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
98859       };
98860     }
98861     catch (std::exception & e) {
98862       {
98863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
98864       };
98865     }
98866     catch (Dali::DaliException e) {
98867       {
98868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
98869       };
98870     }
98871     catch (...) {
98872       {
98873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
98874       };
98875     }
98876   }
98877 }
98878
98879 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
98880 {
98881   void* jresult;
98882   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98883   uint16_t* arg2 = (uint16_t*)(jarg2);
98884   uint16_t* arg3 = (uint16_t*)(jarg3);
98885   uint16_t* arg4 = (uint16_t*)(jarg4);
98886   {
98887     try {
98888       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
98889     }
98890     catch (std::out_of_range & e) {
98891       {
98892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98893       };
98894     }
98895     catch (std::exception & e) {
98896       {
98897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98898       };
98899     }
98900     catch (Dali::DaliException e) {
98901       {
98902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98903       };
98904     }
98905     catch (...) {
98906       {
98907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98908       };
98909     }
98910   }
98911   return jresult;
98912 }
98913
98914 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
98915 {
98916   bool jresult;
98917   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98918
98919   {
98920     try {
98921       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
98922     }
98923     catch (std::out_of_range & e) {
98924       {
98925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98926       };
98927     }
98928     catch (std::exception & e) {
98929       {
98930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98931       };
98932     }
98933     catch (Dali::DaliException e) {
98934       {
98935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98936       };
98937     }
98938     catch (...) {
98939       {
98940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98941       };
98942     }
98943   }
98944   return jresult;
98945 }
98946
98947
98948 #ifdef __cplusplus
98949 }
98950 #endif